adjusted the default configuration so that at least one cpu core remains free (except on single core machines) #332

docs/configuration.rst

@@ -376,8 +376,26 @@ PAPERLESS_THREADS_PER_WORKER=<num>
         use a higher thread per worker count.
 
     The default is a balance between the two, according to your CPU core count,
-    with a slight favor towards threads per worker, and using as much cores as
-    possible.
+    with a slight favor towards threads per worker, and leaving at least one core
+    free for other tasks:
+
+    +----------------+---------+---------+
+    | CPU core count | Workers | Threads |
+    +----------------+---------+---------+
+    |              1 |       1 |       1 |
+    +----------------+---------+---------+
+    |              2 |       1 |       1 |
+    +----------------+---------+---------+
+    |              4 |       1 |       3 |
+    +----------------+---------+---------+
+    |              6 |       2 |       2 |
+    +----------------+---------+---------+
+    |              8 |       2 |       3 |
+    +----------------+---------+---------+
+    |             12 |       3 |       3 |
+    +----------------+---------+---------+
+    |             16 |       3 |       5 |
+    +----------------+---------+---------+
 
     If you only specify PAPERLESS_TASK_WORKERS, paperless will adjust
     PAPERLESS_THREADS_PER_WORKER automatically.

src/documents/tests/test_settings.py

@@ -0,0 +1,34 @@
+import logging
+from unittest import mock
+
+from django.test import TestCase
+
+from paperless.settings import default_task_workers, default_threads_per_worker
+
+
+class TestSettings(TestCase):
+
+    @mock.patch("paperless.settings.multiprocessing.cpu_count")
+    def test_single_core(self, cpu_count):
+        cpu_count.return_value = 1
+
+        default_workers = default_task_workers()
+
+        default_threads = default_threads_per_worker(default_workers)
+
+        self.assertEqual(default_workers, 1)
+        self.assertEqual(default_threads, 1)
+
+    def test_workers_threads(self):
+        for i in range(2, 64):
+            with mock.patch("paperless.settings.multiprocessing.cpu_count") as cpu_count:
+                cpu_count.return_value = i
+
+                default_workers = default_task_workers()
+
+                default_threads = default_threads_per_worker(default_workers)
+
+                self.assertTrue(default_workers >= 1)
+                self.assertTrue(default_threads >= 1)
+
+                self.assertTrue(default_workers * default_threads < i, f"{i}")

src/paperless/settings.py

@@ -345,10 +345,13 @@ LOGGING = {
 # Favors threads per worker on smaller systems and never exceeds cpu_count()
 # in total.
 
+
 def default_task_workers():
+    # always leave one core open
+    available_cores = max(multiprocessing.cpu_count() - 1, 1)
     try:
         return max(
-            math.floor(math.sqrt(multiprocessing.cpu_count())),
+            math.floor(math.sqrt(available_cores)),
             1
         )
     except NotImplementedError:
@@ -365,17 +368,19 @@ Q_CLUSTER = {
 }
 
 
-def default_threads_per_worker():
+def default_threads_per_worker(task_workers):
+    # always leave one core open
+    available_cores = max(multiprocessing.cpu_count() - 1, 1)
     try:
         return max(
-            math.floor(multiprocessing.cpu_count() / TASK_WORKERS),
+            math.floor(available_cores / task_workers),
             1
         )
     except NotImplementedError:
         return 1
 
 
-THREADS_PER_WORKER = os.getenv("PAPERLESS_THREADS_PER_WORKER", default_threads_per_worker())
+THREADS_PER_WORKER = os.getenv("PAPERLESS_THREADS_PER_WORKER", default_threads_per_worker(TASK_WORKERS))
 
 ###############################################################################
 # Paperless Specific Settings                                                 #