zram-advisor 1.0.0__tar.gz

zram_advisor-1.0.0/.gitignore

@@ -0,0 +1,2 @@
+dist/*
+*/__pycache__

zram_advisor-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Joe D
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zram_advisor-1.0.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.1
+Name: zram-advisor
+Version: 1.0.0
+Summary: zRAM status and setup tools
+Project-URL: Homepage, https://github.com/joedefen/zram-advisor
+Project-URL: Bug Tracker, https://github.com/joedefen/zram-advisor/issues
+Author-email: Joe Defen <joedef@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: zram,zram service
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: importlib-metadata; python_version < '3.8'
+Requires-Dist: requests
+Description-Content-Type: text/markdown
+
+> **Quick-start**:
+* If running python 5.11+, install `pipx`, and install with `pipx install zram-advisor`
+* else install `pip`, and install with `pip install zram-advisor --user`
+* `zram-advisor` - reports on currently running zRAM 
+* `zram-advisor --setup` - configure/starts zRAM w defaults on system w/o rRAM already configured.
+
+# zram-advisor: Check/Setup/Test zRAM Tool
+`zram-advisor` can:
+* Check on your running zRAM and report ill advised settings and zRAM effectiveness.
+* Install `fix-zram` which can setup your zRAM and/or reload it with different parameters (e.g., for testing).
+* Provide a browser bookmark file to be imported to help testing your settings.
+
+## Checking Your Running zRAM
+#### Checking with zram-advisor
+Here is the sample output of `zram-advisor` w/o arguments on a system with zRAM running:
+```
+$ zram-advisor 
+          Distro : Linux Mint 21.3
+             180 : vm.swappiness.................. in [150, 200]
+               0 : vm.watermark_boost_factor...... in [0, 0]
+             125 : vm.watermark_scale_factor...... in [125, 125]
+               0 : vm.page-cluster................ in [0, 0]
+            1.6G : zRAM.disksize.................. >= 1.4G
+================ 410s ================
+          952.4M : Total Memory     eTotal=2.2G/239%
+      830.2M/87% : Used              eUsed=1.4G/155%
+      122.3M/13% : Available        eAvail=800.7M/84%
+zram0:
+   uncmpr: 814.5M limit=1.6G
+     cmpr: 158.5M/17% factor=5.14
+     RAM: 165.5M/17% most=240M/25% limit=0
+
+```
+* The top section show key parameters for zRAM and suggested ranges (if it did not like those it would preface the range with "NOT in")
+* The midsection shows traditional key memory stats on the left, and on the right, the "effective values":
+  * **eUsed**: is the amount of memory used if the compressed part in zRAM were expanded; than number is "true".
+  * **eTotal** and **eAvail** are projected numbers based on the current compression ratio; these number are more accurate as the zRAM memory footprint grows increases.
+* The lower section are stats for each zram device .. typically, there is just one.
+    * **uncmpr**: is the amount of "original" memory stored by zRAM; its limit is officially called 'disksize' which is the name/value you see from `zramctl`.
+    * **RAM**: is the amount of physical RAM consumed by zRAM including overhead; **most** it the largest RAM used since boot.
+    
+#### Checking with pmemstat
+Another app (installable with `pipx` or `pip`) is `pmemstat``. The top of it sample output (on the same system as above) was:
+```
+14:41:39 Tot=952.4M Used=741.5M Avail=210.9M Oth=0 Sh+Tmp=8.7M PIDs=122
+     0.6/ker  zRAM=210.2M eTot:2.2G/240% eUsed:1.5G/166% eAvail:705.7M/74%
+ cpu_pct   pswap   other    data  ptotal   key/info (exe by mem)
+     9.8     945     100     195   1,239 T 122x --TOTALS in MB --
+───────────────────────────────────────────────────────────────────────────
+     3.3     396      65     106     567   23x chromium
+```
+* You can see those same "effective" key memory stats, plus you can see kernel cpu% (i.e., the `0.6/ker`). Kernal CPU (most the swap process) can be significant, and that CPU cost is the primary "cost" of using zRAM).
+
+## zram-advisor Options
+```
+usage: zram-advisor [-h] [-s] [-d] [-t] [--DB]
+options:
+  -s, --setup-fix-zram  install "fix-zram" program and start zRAM
+  -d, --dump-fix-zram   print "fix-zram.sh" for manual install
+  -t, --gen-test-sites  print "bookmarks.html" to import to a web-browser for load test
+```
+* **--setup-fix-zram** installs a programs `fix-ram` and creates a service called `fix-zram-init` to run it on boot.
+* **--dump-fix-zram** prints the stock `fix-zram.sh` (e.g., so you can modify it) and install your modified script by running it (e.g., `bash my-fix-zram.sh`).
+* **--gen-test-sites** prints a .html that can be imported into most browsers which creates folders of sites that can be opened to create typical memory demands (of browsers at least).
+
+**Note:** do not install `fix-zram` if w/o uninstalling any competing tool to configure zRAM.
+
+## Controlling zRAM with fix-zram
+`fix-zram.sh` is bash script bundled with `zram-advisor`. Its usage is:
+```
+fix-zram [--(load|reload|unload|setup|unsetup)] [-n|--dry-run] [-cN] [N.Nx] [Nm|Ng]
+where:
+  --{command} defaults to 'load' but can be one of:
+          load      - load/start zRAM  with given params or their defaults
+          reload    - remove any existing zRAM and load zram
+          unload    - unloads any existing zRAM
+          setup     - copy fix-zram to '/usr/local/bin' and setup service [dflt=no]
+          unsetup   - remove '/usr/local/bin/fix-zram' and remove service [dflt=no]
+  -n,--dry-run  - only print commands that would be executed
+  -c{integer}   - set number of zram devices
+  {float}x      - set zram-size to {float} * ram at most [dflt=1.75]
+  {integer}m    - set gross zram-size to {integer} megabytes at most [dflt=12288m]
+  {integer}g    - set gross zram-size to {integer} gigabytes at most
+```
+### fix-zram Run-Time Commands
+`load`, `reload`, and `unload` affect the running system and any effect do not survive reboot. So, these can be used for testing (or initializing) zRAM.
+* `load` and `reload` set the `vm.*` parameters shown by `vram-advisor` (but they do not unset them although a reboot will do that).
+* `unload` and `reload` remove preexisting zRAM if running. Removal only works if all memory stored in zRAM can be placed in memory or another storage device.
+
+Typical use:
+* `fix-zram reload 3x 12g` - will unload the current zRAM (if exists and possible), and then install zRAM with sized at the minimum of 3xRAM and 12GB.
+
+### fix-zram Setup Methods
+* `fix-zram --setup` - installs `fix-zram` and creates a `zram-init-fix` service which will load zRAM per the defaults on each load with default values.
+* `fix-zram --unsetup` - removes the  installed `fix-zram` and removes the `zram-init-fix` service.
+
+Typical use:
+* `fix-zram setup 3x 12g` - installs a zRAM init service that start zRAM sized at the minimum of 3xRAM and 12GB on boot.

zram_advisor-1.0.0/README.md

@@ -0,0 +1,98 @@
+> **Quick-start**:
+* If running python 5.11+, install `pipx`, and install with `pipx install zram-advisor`
+* else install `pip`, and install with `pip install zram-advisor --user`
+* `zram-advisor` - reports on currently running zRAM 
+* `zram-advisor --setup` - configure/starts zRAM w defaults on system w/o rRAM already configured.
+
+# zram-advisor: Check/Setup/Test zRAM Tool
+`zram-advisor` can:
+* Check on your running zRAM and report ill advised settings and zRAM effectiveness.
+* Install `fix-zram` which can setup your zRAM and/or reload it with different parameters (e.g., for testing).
+* Provide a browser bookmark file to be imported to help testing your settings.
+
+## Checking Your Running zRAM
+#### Checking with zram-advisor
+Here is the sample output of `zram-advisor` w/o arguments on a system with zRAM running:
+```
+$ zram-advisor 
+          Distro : Linux Mint 21.3
+             180 : vm.swappiness.................. in [150, 200]
+               0 : vm.watermark_boost_factor...... in [0, 0]
+             125 : vm.watermark_scale_factor...... in [125, 125]
+               0 : vm.page-cluster................ in [0, 0]
+            1.6G : zRAM.disksize.................. >= 1.4G
+================ 410s ================
+          952.4M : Total Memory     eTotal=2.2G/239%
+      830.2M/87% : Used              eUsed=1.4G/155%
+      122.3M/13% : Available        eAvail=800.7M/84%
+zram0:
+   uncmpr: 814.5M limit=1.6G
+     cmpr: 158.5M/17% factor=5.14
+     RAM: 165.5M/17% most=240M/25% limit=0
+
+```
+* The top section show key parameters for zRAM and suggested ranges (if it did not like those it would preface the range with "NOT in")
+* The midsection shows traditional key memory stats on the left, and on the right, the "effective values":
+  * **eUsed**: is the amount of memory used if the compressed part in zRAM were expanded; than number is "true".
+  * **eTotal** and **eAvail** are projected numbers based on the current compression ratio; these number are more accurate as the zRAM memory footprint grows increases.
+* The lower section are stats for each zram device .. typically, there is just one.
+    * **uncmpr**: is the amount of "original" memory stored by zRAM; its limit is officially called 'disksize' which is the name/value you see from `zramctl`.
+    * **RAM**: is the amount of physical RAM consumed by zRAM including overhead; **most** it the largest RAM used since boot.
+    
+#### Checking with pmemstat
+Another app (installable with `pipx` or `pip`) is `pmemstat``. The top of it sample output (on the same system as above) was:
+```
+14:41:39 Tot=952.4M Used=741.5M Avail=210.9M Oth=0 Sh+Tmp=8.7M PIDs=122
+     0.6/ker  zRAM=210.2M eTot:2.2G/240% eUsed:1.5G/166% eAvail:705.7M/74%
+ cpu_pct   pswap   other    data  ptotal   key/info (exe by mem)
+     9.8     945     100     195   1,239 T 122x --TOTALS in MB --
+───────────────────────────────────────────────────────────────────────────
+     3.3     396      65     106     567   23x chromium
+```
+* You can see those same "effective" key memory stats, plus you can see kernel cpu% (i.e., the `0.6/ker`). Kernal CPU (most the swap process) can be significant, and that CPU cost is the primary "cost" of using zRAM).
+
+## zram-advisor Options
+```
+usage: zram-advisor [-h] [-s] [-d] [-t] [--DB]
+options:
+  -s, --setup-fix-zram  install "fix-zram" program and start zRAM
+  -d, --dump-fix-zram   print "fix-zram.sh" for manual install
+  -t, --gen-test-sites  print "bookmarks.html" to import to a web-browser for load test
+```
+* **--setup-fix-zram** installs a programs `fix-ram` and creates a service called `fix-zram-init` to run it on boot.
+* **--dump-fix-zram** prints the stock `fix-zram.sh` (e.g., so you can modify it) and install your modified script by running it (e.g., `bash my-fix-zram.sh`).
+* **--gen-test-sites** prints a .html that can be imported into most browsers which creates folders of sites that can be opened to create typical memory demands (of browsers at least).
+
+**Note:** do not install `fix-zram` if w/o uninstalling any competing tool to configure zRAM.
+
+## Controlling zRAM with fix-zram
+`fix-zram.sh` is bash script bundled with `zram-advisor`. Its usage is:
+```
+fix-zram [--(load|reload|unload|setup|unsetup)] [-n|--dry-run] [-cN] [N.Nx] [Nm|Ng]
+where:
+  --{command} defaults to 'load' but can be one of:
+          load      - load/start zRAM  with given params or their defaults
+          reload    - remove any existing zRAM and load zram
+          unload    - unloads any existing zRAM
+          setup     - copy fix-zram to '/usr/local/bin' and setup service [dflt=no]
+          unsetup   - remove '/usr/local/bin/fix-zram' and remove service [dflt=no]
+  -n,--dry-run  - only print commands that would be executed
+  -c{integer}   - set number of zram devices
+  {float}x      - set zram-size to {float} * ram at most [dflt=1.75]
+  {integer}m    - set gross zram-size to {integer} megabytes at most [dflt=12288m]
+  {integer}g    - set gross zram-size to {integer} gigabytes at most
+```
+### fix-zram Run-Time Commands
+`load`, `reload`, and `unload` affect the running system and any effect do not survive reboot. So, these can be used for testing (or initializing) zRAM.
+* `load` and `reload` set the `vm.*` parameters shown by `vram-advisor` (but they do not unset them although a reboot will do that).
+* `unload` and `reload` remove preexisting zRAM if running. Removal only works if all memory stored in zRAM can be placed in memory or another storage device.
+
+Typical use:
+* `fix-zram reload 3x 12g` - will unload the current zRAM (if exists and possible), and then install zRAM with sized at the minimum of 3xRAM and 12GB.
+
+### fix-zram Setup Methods
+* `fix-zram --setup` - installs `fix-zram` and creates a `zram-init-fix` service which will load zRAM per the defaults on each load with default values.
+* `fix-zram --unsetup` - removes the  installed `fix-zram` and removes the `zram-init-fix` service.
+
+Typical use:
+* `fix-zram setup 3x 12g` - installs a zRAM init service that start zRAM sized at the minimum of 3xRAM and 12GB on boot.

zram_advisor-1.0.0/pyproject.toml

@@ -0,0 +1,69 @@
+# HOW TO PUBLISH...
+#
+# Prep Work (ensure need modules are up-to-date):
+#   sudo pacman -Syu python-pip
+#   sudo pacman -Syu python-build
+#   sudo pacman -Syu python-twine
+#   -- antiquated way
+#      python3 -m pip install --upgrade pip
+#      python3 -m pip install --upgrade build
+#      python3 -m pip install --upgrade twine
+# 
+# PUBLIC Build and deploy (from project directory):
+#   ## BUMP the version (below in [project])
+#   rm -r dist; python3 -m build; ls dist/.
+#   python3 -m twine upload dist/*
+#     ## Enter __token__ and the saved TOKEN (in bitwarden)
+#   pipx upgrade zram-advisor || pipx install zram-advisor # >= python3.11
+#   --OR-- sudo python3 -m pip install zram-advisor # <= python3.10
+#   ## VISIT  https://pypi.org/project/zram-advisor and delete old versions
+#
+# TEST Build and test (from project directory):
+#   ## BUMP the version (below in [project])
+#   rm -r dist; python3 -m build
+#   python3 -m twine upload --repository testpypi dist/*
+#     ## Enter __token__ and the saved TOKEN (in bitwarden)
+#   pip install --upgrade --index-url https://test.pypi.org/simple/ --no-deps --user --break-system-packages zram-advisor
+#   pip uninstall --break-system-packages zram-advisor
+#   ## VISIT  https://test.pypi.org/project/zram-advisor and delete old versions
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+version = "1.0.0"
+name = "zram-advisor"
+authors = [
+    {name = "Joe Defen", email = "joedef@gmail.com"},
+]
+description = "zRAM status and setup tools"
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["zram", "zram service"]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux"
+]
+dependencies = [
+    "requests",
+    'importlib-metadata; python_version<"3.8"',
+]
+
+[project.scripts]
+zram-advisor = "zram_advisor.zram_advisor:run"
+
+[tool.hatch.build.targets.wheel]
+packages = ["zram_advisor"]
+
+[tool.hatch.build.targets.sdist]
+exclude = [
+    "__pycache__",
+    "zram_advisor/__pycache__",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/joedefen/zram-advisor"
+"Bug Tracker" = "https://github.com/joedefen/zram-advisor/issues"

zram_advisor-1.0.0/zram_advisor/__init__.py

@@ -0,0 +1,4 @@
+from .zram_advisor import run
+
+if __name__ == "__main__":
+    run()

zram_advisor-1.0.0/zram_advisor/fix-zram.sh

@@ -0,0 +1,271 @@
+#!/bin/bash
+#
+    #   default kernel settings
+swappiness=180
+watermark_boost_factor=0
+watermark_scale_factor=125
+page_cluster=0
+priority=100
+    #   default options to this script
+factor=1.75
+capM=$((12*1024))  # the default cap on zRAM
+count=1
+dry_run=no
+command=start
+
+usage() {
+    echo "$@"
+    cat <<END
+USE: fix-zram [--(load|reload|unload|setup|unsetup)] [-n|--dry-run] [-cN] [N.Nx] [Nm|Ng]
+where:
+  --{command} defaults to 'load' but can be one of:
+          load      - load/start zRAM  with given params or their defaults
+          reload    - remove any existing zRAM and load zram
+          unload    - unloads any existing zRAM
+          setup     - copy fix-zram to '/usr/local/bin' and setup service
+          unsetup   - remove '/usr/local/bin/fix-zram' and remove service
+  -n,--dry-run  - only print commands that would be executed
+  -c{integer}   - set number of zram devices
+  {float}x      - set zram-size to {float} * ram at most [dflt=$factor]
+  {integer}m    - set gross zram-size to {integer} megabytes at most [dflt=${capM}m]
+  {integer}g    - set gross zram-size to {integer} gigabytes at most
+END
+    exit 1
+}
+
+########################################################
+# restart this program if not root
+if [[ $(id --user) != 0 ]]; then
+    script_tmp_dir=$(realpath "$0")
+    exec sudo bash "${script_tmp_dir}" "$@"
+fi
+
+########################################################
+# Iterate over command-line arguments
+shopt -s extglob # permit patterns like *(-)
+for arg in "$@"; do
+    case "$arg" in
+        [0-9]*[xX]|[0-9]*.[0-9]*[xX])
+            factor="${arg%?}"
+            ;;
+        [0-9]*[mM])
+            capM="${arg%?}"
+            ;;
+        [0-9]*[gG])
+            capG="${arg%?}"
+            capM=$((capG*1024))
+            ;;
+        *(-)c[0-9]*)
+            count="${arg##*c}"
+            ;;
+        *(-)load)       command=load ;;
+        *(-)reload)     command=reload ;;
+        *(-)unload)     command=unload ;;
+        *(-)setup)      command=setup ;;
+        *(-)unsetup)    command=unsetup ;;
+        -n|--dry-run)   dry_run=yes ;;
+        -h|--help|-\?) usage ;;
+        *) usage "Unknown option: $arg"  ;;
+    esac
+done
+
+########################################################
+# Calculations verification
+ramM=$(free -m | awk '/^Mem:/ {print $2}')
+zram_sizeM=$(python3 -c "print(int(round(${factor} * ${ramM})))")
+echo factor=$factor cap=$capM ramM=$ramM zram_size=$zram_sizeM
+if (( capM < zram_sizeM )); then
+    zram_sizeM="${capM}"
+fi
+echo OPTS: $command dry-run=$dry_run count=$count factor=$factor capM=$capM
+echo INFO: ramM=$ramM zram_sizeM=$zram_sizeM
+
+########################################################
+# run a command (or don't)
+run() {
+    if [[ $dry_run == "yes" ]]; then
+        echo 'WOULD ++' "$@"
+    else
+        echo '++' "$@"
+        eval "$@"
+    fi
+}
+
+########################################################
+# unload zram
+unload_zram() {
+    found=no
+    shopt -s nullglob
+    devs=(/dev/zram*)
+    for dev in "${devs[@]}"; do
+        run "swapoff ${dev}"
+        found=yes
+    done
+    shopt -u nullglob
+    run 'modprobe -r zram'
+    if [[ $found == "no" ]]; then
+        echo 'NOTE: zram already unloaded'
+    fi
+    run "zramctl"
+}
+
+########################################################
+# initialize zram
+load_zram() {
+    shopt -s nullglob
+    devs=(/dev/zram*)
+    for dev in "${devs[@]}"; do
+        if [[ $command == 'reload' ]]; then
+            unload_zram
+        else
+            echo "ERROR: ${dev} exists; use --reload to first unload then load"
+            exit -1
+        fi
+        break
+    done
+    shopt -u nullglob
+
+    # unload zswap just in case
+    run "echo 0 > /sys/module/zswap/parameters/enabled"
+
+    run "modprobe zram num_devices=${count}"
+    sizeM=$(python3 -c "print(int(round(${zram_sizeM} / ${count} )))")
+    for (( ii=0; ii<count; ii++ )); do
+        run "echo zstd > /sys/block/zram${ii}/comp_algorithm"
+        run "echo ${sizeM}M > /sys/block/zram${ii}/disksize"
+        run "echo 0 > /sys/block/zram${ii}/mem_limit"
+    done
+
+    run "sysctl -w vm.swappiness=${swappiness} >/dev/null"
+    run "sysctl -w vm.watermark_boost_factor=${watermark_boost_factor} > /dev/null"
+    run "sysctl -w vm.watermark_scale_factor=${watermark_scale_factor} >/dev/null"
+    run "sysctl -w vm.page-cluster=${page_cluster} >/dev/null"
+
+    for (( ii=0; ii<count; ii++ )); do
+        run mkswap /dev/zram${ii}
+        run swapon --priority ${priority} /dev/zram${ii}
+    done
+    run "zramctl"
+}
+
+
+########################################################
+# systemd service setup
+setup_systemd() {
+    dest="/etc/systemd/system/fix-zram.service"
+    service=$(basename "$dest")
+    cat <<END > "${dest}"
+#!/bin/sh
+[Unit]
+Description=Init zRAM on boot
+
+[Service]
+Type=simple
+ExecStart=/bin/bash ${script_bin_path} -c${count} ${factor}x ${capM}M
+
+[Install]
+WantedBy=multi-user.target
+END
+
+    run "chmod 644 '$dest'"
+    run "systemctl enable --now ${service}"
+
+}
+unsetup_systemd() {
+    dest="/etc/systemd/system/fix-zram.service"
+    service=$(basename "$dest")
+    if [ -f "$dest" ]; then
+        run "systemctl disable --now ${service}"
+        run "rm '$dest'"
+    fi
+}
+
+########################################################
+# sysVinit service setup
+setup_sysVinit() {
+    wrapper="/etc/init.d/fix-zram-init"
+    service=$(basename "${wrapper}")
+
+    cat <<END > "${wrapper}"
+#!/bin/bash
+### BEGIN INIT INFO
+# Default-Start:     2 3 4 5
+# Default-Stop:
+### END INIT INFO
+
+case "$1" in
+  start) sudo bash ${script_bin_path} load -c${count} ${factor}x ${capM}M;;
+  stop) sudo bash ${script_bin_path} --unload ;;
+  *)     ;;
+esac
+exit 0
+END
+    run "chmod 755 '$wrapper'"
+
+    if which chkconfig >/dev/null 2>&1; then
+        run "chkconfig --add ${service}"
+    elif which update-rc.d >/dev/null 2>&1; then
+        run "update-rc.d ${wrapper} defaults"
+    fi
+    if which service >/dev/null 2>&1; then
+        run "service $service enable"
+        run "service $service start"
+    elif which update-rc.d >/dev/null 2>&1; then
+        run "update-rd.d $service enable"
+        run "$wrapper start"
+    fi
+
+}
+unsetup_sysVinit() {
+    wrapper="/etc/init.d/fix-zram-init"
+    service=$(basename "${wrapper}")
+    if which service >/dev/null 2>&1; then
+        run "service ${service} stop"
+        run "service ${service} disable"
+    elif which update-rc.d >/dev/null 2>&1; then
+        run "${wrapper} stop"
+        run "update-rd.d ${service} disable"
+    fi
+    run "rm ${wrapper}"
+    if which update-rc.d >/dev/null 2>&1; then
+        run "update-rc.d -f ${service} remove"
+    fi
+    run "rm /var/log/${service}.log"
+}
+
+########################################################
+# setup
+setup() {
+    script_tmp_dir=$(realpath "$0")
+    script_bin_path="/usr/local/bin/fix-zram"
+    ( run "cp '$script_tmp_dir' '$script_bin_path'" )
+
+    init_cmd=$(ps -p 1 -o comm=)
+    case "$init_cmd" in
+      init)    ( setup_sysVinit ) ;;
+      systemd) ( setup_systemd ) ;;
+      *) echo unhandled init type "$init_cmd" ;;
+    esac
+}
+########################################################
+# unsetup
+unsetup() {
+    script_bin_path="/usr/local/bin/fix-zram"
+    init_cmd=$(ps -p 1 -o comm=)
+    case "$init_cmd" in
+      init)    ( unsetup_sysVinit ) ;;
+      systemd) ( unsetup_systemd ) ;;
+      *) echo unhandled init type "$init_cmd" ;;
+    esac
+    rm $script_bin_path
+}
+
+if [[ $command == 'setup' ]]; then
+    setup
+elif [[ $command == 'unsetup' ]]; then
+    unsetup
+elif [[ $command == 'unload' ]]; then
+    unload_zram
+else
+    load_zram
+fi

zram_advisor-1.0.0/zram_advisor/random-sites.txt

@@ -0,0 +1,54 @@
+50waystogetajob.com
+80000hours.org
+www.teamblind.com
+qz.com/work
+brandyourself.com
+www.payscale.com
+getpocket.com
+www.hubspot.com/resources/courses
+internetingishard.netlify.app
+teamtreehouse.com
+www.shopify.com/guides
+www.shopify.com/academy
+www.ted.com
+www.quora.com
+www.blinkist.com
+www.actionablebooks.com/en-ca/summaries
+www.theschooloflife.com/thebookoflife
+www.duolingo.com
+zapier.com/learn
+speaking.io
+review.firstround.com
+degreed.com
+reviewmeta.com
+fast.com
+genius.com
+www.padmapper.com
+workflowy.com
+www.grammarly.com
+trello.com
+www.rescuetime.com
+www.crystalknows.com
+cash.app
+resumeworded.com
+archive.org/web
+discover.getrevue.co
+ifttt.com
+quotecatalog.com
+www.insight-book.com/Quiz.aspx
+ikonick.com
+www.goodreads.com
+weworkremotely.com
+www.freelancewriting.com/jobs
+authenticjobs.com
+angel.co/jobs
+startup.jobs
+invoice-generator.com
+www.hellobonsai.com
+www.indiehackers.com
+www.producthunt.com
+discord.com
+medium.com
+www.patreon.com
+stackexchange.com
+www.thevectorimpact.com

zram_advisor-1.0.0/zram_advisor/zram_advisor.py

@@ -0,0 +1,411 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Program to analyze the zRAM configuration (if any) and suggest
+some improvements.
+
+===== References =====
+www.kernel.org/doc/Documentation/blockdev/zram.txt
+fedoraproject.org/wiki/Changes/Scale_ZRAM_to_full_memory_size
+kernelnewbies.org/Linux_5.8 - when swappiness rose to 2020-08-02
+
+Tested on:
+ - Linux Mint (Mate) 21.3 - 6.5 kernel (upgraded)
+ - Debian (KDE) 12.4.0
+ - Linux Lite 6.6 - 5.x kernel
+ - elementary OS 7.1 Horus
+"""
+# pylint: disable=invalid-name,multiple-statements,global-statement
+# pylint: disable=too-many-instance-attributes,broad-exception-caught
+
+import re
+from types import SimpleNamespace
+import shutil
+import os
+import sys
+import configparser
+import time
+import argparse
+import subprocess
+
+##############################################################################
+
+####################################################################################
+
+class Term:
+    """ Escape sequences; e.g., see:
+     - https://en.wikipedia.org/wiki/ANSI_escape_code
+     - https://gist.github.com/fnky/458719343aabd01cfb17a3a4f7296797#file-ansi-md
+    """
+    esc = '\x1B'
+    # pylint: disable=missing-function-docstring,multiple-statements
+    @staticmethod
+    def erase_line(): return f'{Term.esc}[2K'
+    @staticmethod
+    def bold(): return f'{Term.esc}[1m'
+    @staticmethod
+    def reverse_video(): return f'{Term.esc}[7m'
+    @staticmethod
+    def normal_video(): return f'{Term.esc}[m'
+    @staticmethod
+    def pos_up(cnt): return f'{Term.esc}[{cnt}F' if cnt > 0 else ''
+    @staticmethod
+    def pos_down(cnt): return f'{Term.esc}[{cnt}E' if cnt > 0 else ''
+    @staticmethod
+    def col(pos): return f'{Term.esc}[{pos}G'
+    @staticmethod
+    def clear_screen(): return f'{Term.esc}[H{Term.esc}[2J{Term.esc}[3J'
+
+
+##############################################################################
+def human(number):
+    """ Return a concise number description."""
+    if number <= 0:
+        return '0'
+    suffixes = ['', 'K', 'M', 'G', 'T', 'Q']
+    while suffixes:
+        suffix = suffixes.pop(0)
+        if number < 999.95 or not suffixes:
+            num = f'{number:.1f}'
+            num = num[0:-2] if num.endswith('.0') else num
+            return f'{num}{suffix}'
+        number /= 1024
+    return 'TooHuge'
+
+##############################################################################
+class ZramAdvisor:
+    """ Workhorse class for zram-advisor """
+    def __init__(self):
+        self.meminfo = None #selected info from meminfo
+        self.effective = None # effective system params
+        self.probe = None  # info about runnable programs
+        self.devs = None # info about zram devices
+        self.params = None # related kernel parameters
+        self.release = None
+        self.ram_total = 0
+        self.tab_count = 0  # number of tabs created so far
+        self.download_dir = os.path.expanduser('~/Downloads')
+        self.script_dir = os.path.dirname(os.path.realpath(__file__))
+        # options:
+        self.DB = False
+        self.limit_pct = 80 # arbitrary limit on amount of RAM used by zRAM
+
+    def human_pct(self, number):
+        """ Return the number in human form and as pct total memory. """
+        rv = human(number)
+        if number > 0 and self.ram_total > 0:
+            fraction = number/self.ram_total
+            pct = int(round(100*fraction))
+            rv += f'/{pct}%'
+        return rv
+
+    def get_meminfo(self):
+        """Get most vital stats from /proc/meminfo'"""
+        meminfofile = '/proc/meminfo'
+        meminfo = {'MemTotal': 0, 'MemAvailable': 0, 'Dirty':0, 'Shmem':0}
+        keys = list(meminfo.keys())
+
+        with open(meminfofile, encoding='utf-8') as fileh:
+            for line in fileh:
+                match = re.match(r'^([^:]+):\s+(\d+)\s*kB', line)
+                if not match:
+                    continue
+                key, value = match.group(1), int(match.group(2))
+                if key not in keys:
+                    continue
+                meminfo[key] = value * 1024
+                keys.remove(key)
+                if not keys:
+                    break
+        assert not keys, f'ALERT: cannot get vitals ({keys}) from {meminfofile}'
+        ns = SimpleNamespace(**meminfo)
+        ns.MemUsed = ns.MemTotal - ns.MemAvailable # synthetic
+        if self.DB: print(f'DB: meminfo: {ns}')
+        if self.DB: print(f'DB: RAM={human(ns.MemTotal)}')
+        self.ram_total = ns.MemTotal
+        return ns
+
+    @staticmethod
+    def keyword_in_manpage(manpage, keyword):
+        """ Is a given keyword in the man page?"""
+        try:
+            # Use subprocess to run the man command and grep for the keyword
+            command = f"man {manpage} | grep -q '{keyword}'"
+            subprocess.run(command, shell=True, check=True)
+            return True
+        except subprocess.CalledProcessError:
+            return False
+
+    def prober(self):
+        """ Probe for distro specific attributes """
+        def has(program): # is program on path?
+            return shutil.which(program) is not None
+
+
+        ns = SimpleNamespace(installer=None)
+        ns.fraction_str = ''
+
+        others = ('zramctl', )
+        for other in others:
+            setattr(ns, other, has(other))
+        if self.DB: print(f'DB: probe: {ns}')
+        return ns
+
+    def load_script(self):
+        """ Give the user the onboot script"""
+        pathname = os.path.join(self.script_dir, 'fix-zram.sh')
+        with open(pathname, "r", encoding='utf8') as fh:
+            install_script = fh.read()
+        return install_script
+
+    def setup_script(self, install_script):
+        """ Dump 'fix-zram' into /tmp and run it."""
+        pathname = os.path.join('/tmp', 'fix-zram.sh')
+        with open(pathname, "w", encoding='utf-8') as fh:
+            fh.write(install_script)
+        os.chmod(pathname, 0o755)
+        os.system(f'set -x; sudo bash {pathname} --setup')
+
+    def create_site_import(self):
+        """ Get a randomly chosen site """
+        random_site_file = os.path.join(self.script_dir, 'random-sites.txt')
+        with open(random_site_file, "r", encoding='utf8') as fh:
+            sites = [line.rstrip('\n') for line in fh]
+        rv = """<!DOCTYPE NETSCAPE-Bookmark-file-1>
+<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=UTF-8">
+<TITLE>Bookmarks</TITLE>
+<H1>Bookmarks</H1><DL><p>
+"""
+        rv += '<DT><H3>Rand0</H3><DL><p>\n'
+        for idx, site in enumerate(sites):
+            if idx and idx % 10 == 0:
+                rv += f'</DL><p>\n<DT><H3>Rand{idx//10}</H3><DL><p>\n'
+            href = f'https://{site}/'
+            site = site[4:] if site.startswith('www.') else site
+            rv += f'     <DT><A HREF="{href}">{site}</A>\n'
+        rv += '</DL><p>\n</DL><p>\n'
+        return rv
+
+    def get_zram_stats(self):
+        """ Get only what we want
+         orig_data_size   uncompressed size of data stored in this disk.
+         compr_data_size  compressed size of data stored in this disk
+         mem_used_total   the amount of memory allocated for this disk.
+         mem_limit        max RAM ZRAM can use to store (0 means unlimited)
+         mem_used_max     max RAM zram has consumed to store the data
+        """
+        fields = ('orig_data_size compr_data_size mem_used_total'
+                 + ' mem_limit mem_used_max').split()
+        infos = {}
+        zram_devices = sorted([device for device in os.listdir('/sys/class/block/')
+                    if device.startswith('zram')])
+        for device in zram_devices:
+            statfile = f'/sys/class/block/{device}/mm_stat'
+            if not os.path.exists(statfile):
+                continue # not active
+            with open(statfile, encoding='utf-8') as fileh:
+                ns = SimpleNamespace()
+                for line in fileh: # all the goodies are on 1st line
+                    nums = line.split()
+                    for idx, field in enumerate(fields):
+                        setattr(ns, field, int(nums[idx]))
+                    break
+                infos[device] = ns
+            for param in ('disksize', ):
+                statfile = f'/sys/class/block/{device}/{param}'
+                with open(statfile, encoding='utf-8') as fileh:
+                    for line in fileh: # one value, one line
+                        setattr(ns, param, int(line.strip()))
+                        break
+            if self.DB: print(f'DB: {device}: {ns}')
+
+        return infos
+
+    def get_vm_params(self):
+        """ Looking for (and good values):
+            vm.swappiness = 180
+            vm.watermark_boost_factor = 0
+            vm.watermark_scale_factor = 125
+            vm.page-cluster = 0
+        """
+        def add_param(coll, name, least, most):
+            key = name.replace('-', '_')
+            coll[key] = SimpleNamespace(
+                name=name, value=None, least=least, most=most, key=key)
+        params = {}
+        add_param(params, 'swappiness', 150, 200)
+        add_param(params, 'watermark_boost_factor', 0, 0)
+        add_param(params, 'watermark_scale_factor', 125, 125)
+        add_param(params, 'page-cluster', 0, 0)
+
+        vm_dirname = '/proc/sys/vm'
+        for param in params.values():
+            param_file = os.path.join(vm_dirname, param.name)
+            with open(param_file, encoding='utf-8') as fileh:
+                param.value = int(fileh.readline().strip())
+        if self.DB: print(f'DB: vm.params: {params}')
+        return params
+
+    def get_name_value_info(self, pathname):
+        """ Parse a name=value file; e.g., pathname
+            - keys are made lower case for uniformity because it varies
+            - values are left intact
+        """
+        ns = SimpleNamespace()
+        parser = configparser.ConfigParser()
+        with open(pathname, encoding='utf-8') as stream:
+            parser.read_string('[top]\n' + stream.read())
+
+        for section in parser.sections():
+            for key, value in parser.items(section):
+                setattr(ns, key.lower(), value.replace('"', ''))
+        if self.DB: print(f'DB: {os.path.basename(pathname)}: {ns}')
+        return ns
+
+    def compute_effective(self):
+        """ Compute the effective values """
+        def dump_effective(ns, annotation=''):
+            nonlocal self
+            for key, value in vars(ns).items():
+                print(f'DB: {annotation} {key}: {self.human_pct(value)}')
+
+        if not self.devs:
+            return None
+        meminfo = self.meminfo
+        stats = None
+        for stat in self.devs.values():
+            # NOTE: generalization for more than one weak unless all
+            #        are identically configured
+            if not stats:
+                stats = vars(stat).copy()
+                continue
+            for key, value in vars(stat).items():
+                stats[key] += value
+        stats = SimpleNamespace(**stats)
+
+        ns = SimpleNamespace(e_used=meminfo.MemUsed,
+            e_avail=meminfo.MemAvailable, e_total=meminfo.MemTotal,
+            e_max_used=meminfo.MemTotal, stats=stats)
+        e_used = meminfo.MemUsed - stats.mem_used_total + stats.orig_data_size
+        ratio = None
+        if e_used <= ns.e_used: # zram hurts. assume not enuf data to project
+            e_used = ns.e_used
+            ratio = 3.5 # wild guess for projection
+            # if self.DB: dump_effective(ns, '(unchg)')
+            # return ns
+        ns.e_used = e_used
+        limit_pct = self.limit_pct
+        if stats.mem_limit > 0:
+            stats_limit_pct = (stats.limit / meminfo.MemTotal)*100
+            limit_pct = min(1.0, limit_pct, stats_limit_pct)
+            # projected amount of orig used memory that fits in limit
+        if ratio is None: # hopefully about 4 ;-)
+            ratio = stats.orig_data_size / stats.mem_used_total
+        e_max_used = ratio * meminfo.MemTotal * limit_pct/100
+            # now limit by disksize
+        e_max_used = min(e_max_used, stats.disksize)
+            # now add uncompressed memory
+        e_max_used += meminfo.MemTotal - e_max_used/ratio
+        ns.e_max_used = e_max_used
+        ns.e_avail = e_max_used - e_used
+        if self.DB: dump_effective(ns)
+        return ns
+
+
+    def show_system_summary(self):
+        """ Just the facts, ma'am """
+        print(f'{"Distro":>16} : {self.release.marquee}')
+        for param in self.params.values():
+            ok = '....' if param.least <= param.value <= param.most else ' NOT'
+            print(f'{param.value:>16} : vm.{param.name.ljust(24, ".")}'
+                  f'{ok} in [{param.least}, {param.most}]')
+        if not self.devs:
+            print('   NO zRAM: zRAM is either not installed or not enabled')
+            sys.exit(1)
+        GB = 1024*1024*1024
+        ram = self.meminfo.MemTotal
+        min_disksize = (1.5*ram if ram <= 8*GB else 4*GB)
+        actual_disksize = self.effective.stats.disksize
+        ok = '....' if min_disksize <= actual_disksize else ' NOT'
+        print(f'{human(actual_disksize):>16} : {"zRAM.disksize".ljust(27, ".")}'
+              f'{ok} >= {human(min_disksize)}')
+
+        start = time.time()
+        time.sleep(2)
+        for _ in range(1000*1000):
+            meminfo = self.meminfo
+            eff = self.effective
+            delta = int(round(time.time() - start))
+            print('='*16, f'{delta}s', '='*16)
+            print(f'{human(self.meminfo.MemTotal):>16} : {"Total Memory":<16}',
+                        f'eTotal={self.human_pct(eff.e_max_used)}')
+            print(f'{self.human_pct(meminfo.MemUsed):>16} : {"Used":<16}',
+                        f' eUsed={self.human_pct(eff.e_used)}')
+            print(f'{self.human_pct(meminfo.MemAvailable):>16} : {"Available":<16}',
+                        f'eAvail={self.human_pct(eff.e_avail)}')
+            for dev, stats in self.devs.items():
+                print(f'{dev}:')
+                print(f'   uncmpr: {human(stats.orig_data_size)} limit={human(stats.disksize)}')
+                factor = (stats.orig_data_size/stats.compr_data_size
+                            if stats.compr_data_size > 0 else 0)
+                print(f'     cmpr: {self.human_pct(stats.compr_data_size)}',
+                        f'factor={factor:.2f}')
+                print(f'     RAM: {self.human_pct(stats.mem_used_total)}'
+                                    if stats.mem_used_total > 0 else 'n/a',
+                        f'most={self.human_pct(stats.mem_used_max)}',
+                        f'limit={self.human_pct(stats.mem_limit)}')
+            if self.DB:
+                break
+            time.sleep(1)
+            self.meminfo = self.get_meminfo()
+            self.devs = self.get_zram_stats()
+            self.effective = self.compute_effective()
+
+            emit = Term.pos_up(1) + Term.erase_line() + '\r'
+            print((4 + len(self.devs) * 4) * emit, end='')
+
+    def main(self):
+        """ Do something useful. """
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-s', '--setup-fix-zram', action="store_true",
+                help='install "fix-zram" program and start zRAM')
+        parser.add_argument('-d', '--dump-fix-zram', action="store_true",
+                help='print "fix-zram.sh" for manual install')
+        parser.add_argument('-t', '--gen-test-sites', action="store_true",
+                help='print "bookmarks.html" to import to a web-browser for load test')
+        parser.add_argument('--DB', action="store_true",
+                help='debug creation of low-level objects/data')
+        opts = parser.parse_args()
+
+        try:
+            self.release = self.get_name_value_info('/etc/os-release')
+            self.release.marquee = self.release.pretty_name
+        except Exception:
+            try:
+                self.release = self.get_name_value_info('/etc/lsb-release')
+                self.release.marquee = self.distrib_description
+            except Exception:
+                print("cannot get os-release or lsb-release")
+
+        if opts.dump_fix_zram:
+            install_script = self.load_script()
+            print(install_script, end='')
+        elif opts.setup_fix_zram:
+            install_script = self.load_script()
+            self.setup_script(install_script)
+        elif opts.gen_test_sites:
+            import_html = self.create_site_import()
+            print(import_html, end='')
+        else:
+            self.meminfo = self.get_meminfo()
+            self.probe = self.prober()
+            self.devs = self.get_zram_stats()
+            self.params = self.get_vm_params()
+            self.effective = self.compute_effective()
+            self.show_system_summary()
+def run():
+    """ Entry point"""
+    ZramAdvisor().main()
+    
+if __name__ == "__main__":
+    run()