tree bab5c65b9fcdc0970a61f46646fcf4c8501506a8
parent 28c6828528a8f38e2b2dca6eb01b688053e67e08
author dahn <daan.hoogland@gmail.com> 1650937312 +0200
committer GitHub <noreply@github.com> 1650937312 -0300
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJiZ03gCRBK7hj4Ov3rIwAAYuAIAHeSrj+xJmmsBUbo3OPo9WMC
 19+ITOMWkelajb90IaLtrFBKwFF9q/DMgbcWV4CjyfAeCW+oQ0jF5xplPpoGsuFS
 V/zhSEIIVH2d1FW7t9Wj3vULANCKE33lJK//GP6zc14wM9OB+HDBeQVZVKZ3EeD/
 0RDRsI0pgtw5KmyAbgP7JCf9bYRUkC1+Omms+pvFCiDtAMdz+0jk1mP6Up4HrnPQ
 o5xdiNa0iU36wUxi9oYO6zxERsFzaubK5HCThuhNzQvZ2EWPN747r4YJQMIr/9X1
 v3nl8vge/BgAamKtJaQFoWNImVgCmflJxMRaW0Lz9nCtcMVhYLmgunFFvH8SAkE=
 =Qowf
 -----END PGP SIGNATURE-----
 

db load averages explained (#256)

* db load averages explained

* Update source/adminguide/tuning.rst

Co-authored-by: sureshanaparti <12028987+sureshanaparti@users.noreply.github.com>

* Update source/adminguide/tuning.rst

Co-authored-by: sureshanaparti <12028987+sureshanaparti@users.noreply.github.com>

* show picture?

* default retation changed

It is now three instead of ten interations retained

* display new texts

* Apply suggestions from code review

Co-authored-by: Nicolas Vazquez <nicovazquez90@gmail.com>

Co-authored-by: Daan Hoogland <dahn@onecht.net>
Co-authored-by: sureshanaparti <12028987+sureshanaparti@users.noreply.github.com>
Co-authored-by: Nicolas Vazquez <nicovazquez90@gmail.com>