Repository: modin-project/modin
Pull request: DOCS-#2940: add documentation for asv 
Signed-off-by: Anatoly Myachev <anatoly.myachev@intel.com>

<!--
Thank you for your contribution!
Please review the contributing docs: https://modin.readthedocs.io/en/latest/CONTRIBUTING.html
if you have questions about contributing.
-->

## What do these changes do?

<!-- Please give a short brief about these changes. -->

- [x] commit message follows format outlined [here](https://modin.readthedocs.io/en/latest/contributing.html)
- [x] passes `flake8 modin`
- [x] passes `black --check modin`
- [x] signed commit with `git commit -s` <!-- you can amend your commit with a signature via `git commit -amend -s` -->
- [x] Resolves #2940 <!-- issue must be created for each patch -->
- [x] tests added and passing


Problem statement:
Document asv bench and CI
This should document what we do in asv benchmarking, how we produce the results (and steps for any 3rd party to reproduce the measurements).

It should also document everything about how we run CI on GitHub and TeamCity

Hints from issue discussion:

Commit message: DOCS-#2940: add function level docstrings

Signed-off-by: Anatoly Myachev <anatoly.myachev@intel.com>

Patch to review:
diff --git a/asv_bench/README.md b/asv_bench/README.md
new file mode 100644
index 00000000000..5f914e6f2b3
--- /dev/null
+++ b/asv_bench/README.md
@@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
+  The launch takes place on our own server by using teamcity configuration.
+  The description of the server can be found in the dashboard.
+  This step starts as scheduled (now every half hour), subject to the presence of new commits in the modin master branch.
+  Command to run benchmarks: `asv run HASHFILE:hashfile.txt --show-stderr --machine xeon-e5 --launch-method=spawn`.
+  In the file `hashfile.txt` is the last modin commit hash.
+  Writing to a `modin-bench@master` triggers 3 step of the pipeline.
+
+3 step: converting the results to html representation, which is saved in [modin-bench@gh-pages](https://github.com/modin-project/modin-bench)
+  The implementation can be found in `deploy-gh-pages` job of [push.yml](https://github.com/modin-project/modin-bench/blob/master/.github/workflows/push.yml)
+
+Basic actions for 2 step:
+* install packages to proper installation ray dependencies via pip:
+  * gcc
+  * python3-dev
+* setup environment variable:
+  * export MODIN_TEST_DATASET=Big
+  * export MODIN_CPUS=44
+* setup git client
+* prepare json file with machine description
+* copy old result to folder where new result wiil be appeared
+  (the solution of conflicts will be undertaken by ASV itself instead of git)
+* push performance result to modin-bench repository
\ No newline at end of file
diff --git a/asv_bench/benchmarks/benchmarks.py b/asv_bench/benchmarks/benchmarks.py
index c9e89cc828f..9f58d25cbb9 100644
--- a/asv_bench/benchmarks/benchmarks.py
+++ b/asv_bench/benchmarks/benchmarks.py
@@ -11,6 +11,8 @@
 # ANY KIND, either express or implied. See the License for the specific language
 # governing permissions and limitations under the License.
 
+"""General modin benchmarks"""
+
 # define `MODIN_CPUS` env var to control the number of partitions
 # it should be defined before modin.pandas import (in case of using os.environ)
 
diff --git a/asv_bench/benchmarks/io/__init__.py b/asv_bench/benchmarks/io/__init__.py
index cae6413e559..b9de9c795ee 100644
--- a/asv_bench/benchmarks/io/__init__.py
+++ b/asv_bench/benchmarks/io/__init__.py
@@ -10,3 +10,5 @@
 # the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 # ANY KIND, either express or implied. See the License for the specific language
 # governing permissions and limitations under the License.
+
+"""IO modin benchmarks"""
diff --git a/asv_bench/benchmarks/scalability/__init__.py b/asv_bench/benchmarks/scalability/__init__.py
index cae6413e559..841cc61aaea 100644
--- a/asv_bench/benchmarks/scalability/__init__.py
+++ b/asv_bench/benchmarks/scalability/__init__.py
@@ -10,3 +10,5 @@
 # the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
 # ANY KIND, either express or implied. See the License for the specific language
 # governing permissions and limitations under the License.
+
+"""Modin benchmarks with MODIN_CPUS change"""
diff --git a/asv_bench/benchmarks/utils.py b/asv_bench/benchmarks/utils.py
index a76046be7b8..0195adbd677 100644
--- a/asv_bench/benchmarks/utils.py
+++ b/asv_bench/benchmarks/utils.py
@@ -11,12 +11,20 @@
 # ANY KIND, either express or implied. See the License for the specific language
 # governing permissions and limitations under the License.
 
+"""
+This module contains the functionality that is used when benchmarking modin commits.
+In the case of using utilities from the main modin code, there is a chance that when
+benchmarking old commits, the utilities changed, which in turn can unexpectedly affect
+the performance results.
+"""
+
 import os
 import logging
 import modin.pandas as pd
 import pandas
 import numpy as np
 import uuid
+from typing import Union
 
 RAND_LOW = 0
 RAND_HIGH = 100
@@ -90,7 +98,19 @@
 }
 
 
-def translator_groupby_ngroups(groupby_ngroups, shape):
+def translator_groupby_ngroups(groupby_ngroups: Union[str, int], shape: tuple) -> int:
+    """
+    Translate a string representation of the number of groups, into a number.
+
+    Parameters
+    ----------
+    groupby_ngroups:
+    shape: tuple
+
+    Return
+    ------
+    int
+    """
     if ASV_DATASET_SIZE == "big":
         if groupby_ngroups == "huge_amount_groups":
             return min(shape[0] // 2, 5000)
@@ -107,7 +127,26 @@ class weakdict(dict):
 dataframes_cache = dict()
 
 
-def gen_int_data(nrows, ncols, rand_low, rand_high):
+def gen_int_data(nrows: int, ncols: int, rand_low: int, rand_high: int) -> dict:
+    """
+    Generate int data with caching.
+
+    Parameters
+    ----------
+    nrows: int
+        number of rows
+    ncols: int
+        number of columns
+    rand_low: int
+        low bound for random generator
+    rand_high:int
+        high bound for random generator
+
+    Return
+    ------
+    dict
+        ncols number of keys, storing numpy.array of nrows length
+    """
     cache_key = ("int", nrows, ncols, rand_low, rand_high)
     if cache_key in data_cache:
         return data_cache[cache_key]
@@ -125,7 +164,27 @@ def gen_int_data(nrows, ncols, rand_low, rand_high):
     return data
 
 
-def gen_str_int_data(nrows, ncols, rand_low, rand_high):
+def gen_str_int_data(nrows: int, ncols: int, rand_low: int, rand_high: int) -> dict:
+    """
+    Generate int data and string data with caching.
+
+    Parameters
+    ----------
+    nrows: int
+        number of rows
+    ncols: int
+        number of columns
+    rand_low: int
+        low bound for random generator
+    rand_high:int
+        high bound for random generator
+
+    Return
+    ------
+    dict
+        ncols+1 number of keys, storing numpy.array of nrows length
+        one column with string values
+    """
     cache_key = ("str_int", nrows, ncols, rand_low, rand_high)
     if cache_key in data_cache:
         return data_cache[cache_key]
@@ -143,7 +202,31 @@ def gen_str_int_data(nrows, ncols, rand_low, rand_high):
     return data
 
 
-def gen_data(data_type, nrows, ncols, rand_low, rand_high):
+def gen_data(
+    data_type: str, nrows: int, ncols: int, rand_low: int, rand_high: int
+) -> dict:
+    """
+    Generate data with caching.
+
+    Parameters
+    ----------
+    data_type: str
+        type of data generation
+    nrows: int
+        number of rows
+    ncols: int
+        number of columns
+    rand_low: int
+        low bound for random generator
+    rand_high:int
+        high bound for random generator
+
+    Return
+    ------
+    dict
+        ncols+1 number of keys, storing numpy.array of nrows length
+        one column with string values
+    """
     if data_type == "int":
         return gen_int_data(nrows, ncols, rand_low, rand_high)
     elif data_type == "str_int":
@@ -211,20 +294,57 @@ def generate_dataframe(
     return df
 
 
-def random_string():
-    return str(uuid.uuid1())
+def random_string() -> str:
+    """
+    Create 36 character random strings using functionality from `uuid` module.
+
+    Return
+    ------
+    str
+    """
+    return str(uuid.uuid4())
+
+
+def random_columns(df_columns: list, columns_number: int) -> list:
+    """
+    Create list of random columns from a given sequence.
 
+    Parameters
+    ----------
+    df_columns: list
+    columns_number: int
 
-def random_columns(df_columns, columns_number):
+    Return
+    ------
+    list
+    """
     return list(random_state.choice(df_columns, size=columns_number))
 
 
-def random_booleans(number):
+def random_booleans(number: int) -> list:
+    """
+    Create random list of booleans with `number` elements.
+
+    Parameters
+    ----------
+    number: int
+        count of booleans in result list
+
+    Return
+    ------
+    list
+    """
     return list(random_state.choice([True, False], size=number))
 
 
-def execute(df):
-    "Make sure the calculations are done."
+def execute(df: Union[pd.DataFrame, pandas.DataFrame]):
+    """
+    Make sure the calculations are done.
+
+    Parameters
+    ----------
+    df: modin.DataFrame of pandas.Datarame
+    """
     if ASV_USE_IMPL == "modin":
         partitions = df._query_compiler._modin_frame._partitions
         all(
@@ -248,5 +368,16 @@ def execute(df):
         pass
 
 
-def get_shape_id(array):
-    return "_".join([str(element) for element in array])
+def get_shape_id(shape: tuple) -> str:
+    """
+    Join shape numbers into a string with `_` delimiters.
+
+    Parameters
+    ----------
+    shape: tuple
+
+    Return
+    ------
+    str
+    """
+    return "_".join([str(element) for element in shape])
diff --git a/docs/contributing.rst b/docs/contributing.rst
index 5f667caa779..20449470619 100644
--- a/docs/contributing.rst
+++ b/docs/contributing.rst
@@ -171,46 +171,7 @@ Performance measurement
 We use Asv_ tool for performance tracking of various Modin functionality. The results
 can be viewed here: `Asv dashboard`_.
 
-Here are some scenarios in which Asv can be used:
-
-* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
-
-.. code-block:: bash
-
-  asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn
-
-* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
-
-.. code-block:: bash
-
-  asv run --quick --show-stderr --python=same --launch-method=spawn
-
-* You just need to run the entire test suite to get the current time numbers:
-
-.. code-block:: bash
-
-  asv run --launch-method=spawn
-
-* It is necessary to check the range of commits for performance degradation:
-
-.. code-block:: bash
-
- asv run [start_hash]..[end_hash] --launch-method=spawn
- asv publish
- asv preview
-
-For more consistent results, you may need to use the following parameters:
-
-* ``-a sample_time=1``
-* ``-a warmup_time=1``
-* ``-a processes=4``
-
-Some details about using Modin on Ray with Asv:
-
-* ``--launch-method=forkserver`` is not working
-* Each set of parameters for each test is launched in its own process, which brings
-  a large overhead, since for each process redis server and other necessary binaries
-  from ray initialization are started and destroyed.
+More information can be found in the `Asv readme`_.
 
 
 Building documentation
@@ -252,3 +213,4 @@ More docs on this coming soon...
 .. _Asv: https://github.com/airspeed-velocity/asv#airspeed-velocity
 .. _developer mailing list: https://groups.google.com/forum/#!forum/modin-dev
 .. _Asv dashboard: https://modin.org/modin-bench/#/
+.. _Asv readme: https://github.com/modin-project/modin/blob/master/asv_bench/README.md


Code review comments:
diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
path: asv_bench/README.md
text: @user2:
```suggestion
Step 2: running benchmarks with saving the results in [modin-bench@user1](https://github.com/modin-project/modin-bench).
```

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
+  The launch takes place on our own server by using teamcity configuration.
+  The description of the server can be found in the dashboard.
+  This step starts as scheduled (now every half hour), subject to the presence of new commits in the modin master branch.
+  Command to run benchmarks: `asv run HASHFILE:hashfile.txt --show-stderr --machine xeon-e5 --launch-method=spawn`.
+  In the file `hashfile.txt` is the last modin commit hash.
+  Writing to a `modin-bench@master` triggers 3 step of the pipeline.
+
+3 step: converting the results to html representation, which is saved in [modin-bench@gh-pages](https://github.com/modin-project/modin-bench)
path: asv_bench/README.md
text: @user2:
```suggestion
Step 3: converting the results to html representation, which is saved in [modin-bench@user1-pages](https://github.com/modin-project/modin-bench)
```

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
+  The launch takes place on our own server by using teamcity configuration.
+  The description of the server can be found in the dashboard.
+  This step starts as scheduled (now every half hour), subject to the presence of new commits in the modin master branch.
+  Command to run benchmarks: `asv run HASHFILE:hashfile.txt --show-stderr --machine xeon-e5 --launch-method=spawn`.
+  In the file `hashfile.txt` is the last modin commit hash.
+  Writing to a `modin-bench@master` triggers 3 step of the pipeline.
+
+3 step: converting the results to html representation, which is saved in [modin-bench@gh-pages](https://github.com/modin-project/modin-bench)
+  The implementation can be found in `deploy-gh-pages` job of [push.yml](https://github.com/modin-project/modin-bench/blob/master/.github/workflows/push.yml)
+
+Basic actions for 2 step:
+* install packages to proper installation ray dependencies via pip:
path: asv_bench/README.md
text: @user1:
why is that necessary? isn't `pip install ray` enough?

@author:
Now this is not needed, apparently it has been preserved from fairly old dependencies. So removed these lines.

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
+  The launch takes place on our own server by using teamcity configuration.
+  The description of the server can be found in the dashboard.
+  This step starts as scheduled (now every half hour), subject to the presence of new commits in the modin master branch.
+  Command to run benchmarks: `asv run HASHFILE:hashfile.txt --show-stderr --machine xeon-e5 --launch-method=spawn`.
+  In the file `hashfile.txt` is the last modin commit hash.
+  Writing to a `modin-bench@master` triggers 3 step of the pipeline.
+
+3 step: converting the results to html representation, which is saved in [modin-bench@gh-pages](https://github.com/modin-project/modin-bench)
+  The implementation can be found in `deploy-gh-pages` job of [push.yml](https://github.com/modin-project/modin-bench/blob/master/.github/workflows/push.yml)
+
+Basic actions for 2 step:
+* install packages to proper installation ray dependencies via pip:
+  * gcc
+  * python3-dev
+* setup environment variable:
+  * export MODIN_TEST_DATASET=Big
+  * export MODIN_CPUS=44
+* setup git client
+* prepare json file with machine description
+* copy old result to folder where new result wiil be appeared
+  (the solution of conflicts will be undertaken by ASV itself instead of git)
path: asv_bench/README.md
text: @user1:
```suggestion
* copy old result to folder where new result will appear
  (conflict resolution will be performed by ASV itself instead of git)
```

diff_hunk: @@ -211,20 +294,57 @@ def generate_dataframe(
     return df
 
 
-def random_string():
-    return str(uuid.uuid1())
+def random_string() -> str:
+    """
+    Create 36 character random strings using functionality from `uuid` module.
path: asv_bench/benchmarks/utils.py
text: @user1:
```suggestion
    Create 36-character random strings.
```
Docstring does not have to explain _how_ stuff is done unless it is critical for the function's role.

Based on function name I think we don't care that these numbers are actually UUID-s. If that isn't true (i.e. if we rely somewhere on them being UUIDs) we should rename the function.

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
path: asv_bench/README.md
text: @user1:
```suggestion
  a large overhead, since for each process redis server and other necessary processes
```

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
path: asv_bench/README.md
text: @user1:
```suggestion
Step 1: checking benchmarks for validity, runs in PRs CI.
```

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
+of the environment variable `MODIN_ASV_USE_IMPL` is selected.
+* the size of the benchmark dataset should depend on the environment variable `MODIN_TEST_DATASET_SIZE`.
+
+## How to change a existing benchmark?
+
+It should be remembered that the hash calculated from the benchmark source code is used to display the results.
+When changing the benchmark, the old results will no longer be displayed in the dashboard. In general, this is the correct
+behavior so as not to get a situation when incomparable numbers are displayed in the dashboard.
+But it should be noted that there are such changes in the source code, in which it is still correct to compare
+the "before" and "after" versions, for example, the name of a variable, etc.
+In this case, you must either run a new version of the benchmark for all the commits ever counted, or manually change
+the hash in the corresponding result files.
+
+## Pipeline for displaying results in a dashboard.
+
+1 step: checking benchmarks for validity, runs in PRs CI.
+  During the test, the benchmarks are run once on small data.
+  The implementation can be found in `test-asv-benchmarks` job of [ci.yml](https://github.com/modin-project/modin/blob/master/.github/workflows/ci.yml)
+
+2 step: running benchmarks with saving the results in [modin-bench@master](https://github.com/modin-project/modin-bench).
+  The launch takes place on our own server by using teamcity configuration.
+  The description of the server can be found in the dashboard.
path: asv_bench/README.md
text: @user1:
can we add a link to said description?

diff_hunk: @@ -0,0 +1,87 @@
+# Modin ASV benchmarks
+
+## Here are some scenarios in which [ASV](https://asv.readthedocs.io/en/stable/index.html) can be used:
+
+* It is necessary to check the impact of the new patch on the performance of a certain set of operations:
+
+  `asv continuous -f 1.05 src/master HEAD -b TimeGroupBy --launch-method=spawn`
+
+* It is necessary to check presence of errors inside of benchmarks after making changes or writing new ones:
+
+  `asv run --quick --show-stderr --python=same --launch-method=spawn`
+
+* You just need to run the entire test suite to get the current time numbers:
+
+  `asv run --launch-method=spawn`
+
+* It is necessary to check the range of commits for performance degradation:
+
+  ```
+  asv run [start_hash]..[end_hash] --launch-method=spawn
+  asv publish
+  asv preview
+  ```
+
+For more consistent results, you may need to use the following parameters:
+
+* `-a sample_time=1`
+* `-a warmup_time=1`
+
+### Some details about using Modin on Ray with Asv:
+
+* `--launch-method=forkserver` is not working;
+* Each set of parameters for each test is launched in its own process, which brings
+  a large overhead, since for each process redis server and other necessary binaries
+  from ray initialization are started and destroyed.
+
+## How to add a new benchmark?
+
+Basic information on how to write benchmarks - [link](https://asv.readthedocs.io/en/stable/writing_benchmarks.html)
+
+As examples, benchmarks from `benchmarks/benchmarks.py`, `benchmarks/scalability/scalability_benchmarks.py` or `benchmarks/io/csv.py`
+can be used.
+
+Requirements:
+* the benchmark should be able to run both on modin and on the clean pandas when the appropriate value
path: asv_bench/README.md
text: @user1:
```suggestion
* the benchmark should be able to run both on Modin and on Pandas when the appropriate value
```