[IMP] orm: add optional // attr call to iter_browse

In some cases, e.g. if it is known that calling a certain method on the model
will only trigger inserts or it is clear that updates will be disjunct, such
method calls can be done in parallel.

Author: cawo-odoo

src/util/orm.py

@@ -9,8 +9,11 @@
 on this module work along the ORM of *all* supported versions.
 """
 
+import collections
 import logging
+import os
 import re
+from concurrent.futures import ProcessPoolExecutor
 from contextlib import contextmanager
 from functools import wraps
 from itertools import chain
@@ -27,9 +30,9 @@
     except ImportError:
         from odoo import SUPERUSER_ID
     from odoo import fields as ofields
-    from odoo import modules, release
+    from odoo import modules, release, sql_db
 except ImportError:
-    from openerp import SUPERUSER_ID, modules, release
+    from openerp import SUPERUSER_ID, modules, release, sql_db
 
     try:
         from openerp import fields as ofields
@@ -41,8 +44,8 @@
 from .const import BIG_TABLE_THRESHOLD
 from .exceptions import MigrationError
 from .helpers import table_of_model
-from .misc import chunks, log_progress, version_between, version_gte
-from .pg import column_exists, format_query, get_columns, named_cursor
+from .misc import chunks, log_progress, str2bool, version_between, version_gte
+from .pg import column_exists, format_query, get_columns, get_max_workers, named_cursor
 
 # python3 shims
 try:
@@ -52,6 +55,8 @@
 
 _logger = logging.getLogger(__name__)
 
+UPG_PARALLEL_ITER_BROWSE = str2bool(os.environ.get("UPG_PARALLEL_ITER_BROWSE", "0"))
+
 
 def env(cr):
     """
@@ -338,6 +343,23 @@ def get_ids():
         invalidate(records)
 
 
+def _mp_iter_browse_cb(ids_or_values):
+    me = _mp_iter_browse_cb
+    # init upon first call. Done here instead of initializer callback, because py3.6 doesn't have it
+    if not hasattr(me, "env"):
+        sql_db._Pool = None  # children cannot borrow from copies of the same pool, it will cause protocol error
+        me.env = env(sql_db.db_connect(me.params["dbname"]).cursor())
+        me.env.clear()
+    # process
+    if me.params["mode"] == "browse":
+        getattr(me.env[me.params["model_name"]].browse(ids_or_values), me.params["attr_name"])(
+            *me.params["args"], **me.params["kwargs"]
+        )
+    if me.params["mode"] == "create":
+        me.env[me.params["model_name"]].create(ids_or_values)
+    me.env.cr.commit()
+
+
 class iter_browse(object):
     """
     Iterate over recordsets.
@@ -372,12 +394,11 @@ class iter_browse(object):
     :param model: the model to iterate
     :type model: :class:`odoo.model.Model`
     :param iterable(int) ids: iterable of IDs of the records to iterate
-    :param int chunk_size: number of records to load in each iteration chunk, `200` by
-                           default
+    :param int chunk_size: number of records to load in each iteration chunk, `200` by default
     :param logger: logger used to report the progress, by default
                    :data:`~odoo.upgrade.util.orm._logger`
     :type logger: :class:`logging.Logger`
-    :param str strategy: whether to `flush` or `commit` on each chunk, default is `flush`
+    :param str strategy: whether to `flush`, `commit` or `multiprocess` each chunk, default is `flush`
     :return: the object returned by this class can be used to iterate, or call any model
              method, safely on millions of records.
 
@@ -400,7 +421,19 @@ def __init__(self, model, *args, **kw):
         self._chunk_size = kw.pop("chunk_size", 200)  # keyword-only argument
         self._logger = kw.pop("logger", _logger)
         self._strategy = kw.pop("strategy", "flush")
-        assert self._strategy in {"flush", "commit"}
+        assert self._strategy in {"flush", "commit", "multiprocessing"}
+        if self._strategy == "multiprocessing":
+            if UPG_PARALLEL_ITER_BROWSE:
+                self._task_size = self._chunk_size
+                self._chunk_size = max(get_max_workers() * 10 * self._task_size, 1000000)
+            elif self._size > 100000:
+                _logger.warning(
+                    "Browsing %d %s, which may take a long time. "
+                    "This can be sped up by setting the env variable UPG_PARALLEL_ITER_BROWSE to 1. "
+                    "If you do, be sure to examine the results carefully.",
+                    self._size,
+                    self._model._name,
+                )
         if kw:
             raise TypeError("Unknown arguments: %s" % ", ".join(kw))
 
@@ -417,8 +450,10 @@ def _browse(self, ids):
         return self._model.browse(*args)
 
     def _end(self):
-        if self._strategy == "commit":
+        if self._strategy in ["commit", "multiprocessing"]:
             self._model.env.cr.commit()
+            if self._strategy == "multiprocessing" and UPG_PARALLEL_ITER_BROWSE:
+                delattr(_mp_iter_browse_cb, "params")
         else:
             flush(self._model)
         invalidate(self._model, *self._cr_uid)
@@ -452,6 +487,25 @@ def __getattr__(self, attr):
 
         def caller(*args, **kwargs):
             args = self._cr_uid + args
+            if self._strategy == "multiprocessing" and UPG_PARALLEL_ITER_BROWSE:
+                _mp_iter_browse_cb.params = {
+                    "dbname": self._model.env.cr.dbname,
+                    "model_name": self._model._name,
+                    "attr_name": attr,
+                    "args": args,
+                    "kwargs": kwargs,
+                    "mode": "browse",
+                }
+                with ProcessPoolExecutor(max_workers=get_max_workers()) as executor:
+                    for chunk in it:
+                        collections.deque(
+                            executor.map(_mp_iter_browse_cb, chunks(chunk._ids, self._task_size, fmt=tuple)),
+                            maxlen=0,
+                        )
+                next(self._end(), None)
+                # do not return results in // mode, we expect it to be used for huge numbers of
+                # records and thus would risk MemoryError
+                return None
             return [getattr(chnk, attr)(*args, **kwargs) for chnk in chain(it, self._end())]
 
         self._it = None