[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,14 +9,23 @@
 on this module work along the ORM of *all* supported versions.
 """
 
+import collections
 import logging
+import multiprocessing
+import os
 import re
+import sys
 import uuid
 from contextlib import contextmanager
 from functools import wraps
-from itertools import chain
+from itertools import chain, repeat
 from textwrap import dedent
 
+try:
+    from concurrent.futures import ProcessPoolExecutor
+except ImportError:
+    ProcessPoolExecutor = None
+
 try:
     from unittest.mock import patch
 except ImportError:
@@ -28,9 +37,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
@@ -42,8 +51,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 SQLStr, column_exists, format_query, get_columns, named_cursor
+from .misc import chunks, log_progress, str2bool, version_between, version_gte
+from .pg import SQLStr, column_exists, format_query, get_columns, get_max_workers, named_cursor
 
 # python3 shims
 try:
@@ -53,6 +62,10 @@
 
 _logger = logging.getLogger(__name__)
 
+UPG_PARALLEL_ITER_BROWSE = str2bool(os.environ.get("UPG_PARALLEL_ITER_BROWSE", "0"))
+# FIXME: for CI! Remove before merge
+UPG_PARALLEL_ITER_BROWSE = True
+
 
 def env(cr):
     """
@@ -342,6 +355,23 @@ def get_ids():
     cr.execute("DROP TABLE IF EXISTS _upgrade_rf")
 
 
+def _mp_iter_browse_cb(ids_or_values, params):
+    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(params["dbname"]).cursor())
+        me.env.clear()
+    # process
+    if params["mode"] == "browse":
+        getattr(
+            me.env[params["model_name"]].with_context(params["context"]).browse(ids_or_values), params["attr_name"]
+        )(*params["args"], **params["kwargs"])
+    if params["mode"] == "create":
+        me.env[params["model_name"]].with_context(params["context"]).create(ids_or_values)
+    me.env.cr.commit()
+
+
 class iter_browse(object):
     """
     Iterate over recordsets.
@@ -389,7 +419,18 @@ class iter_browse(object):
     See also :func:`~odoo.upgrade.util.orm.env`
     """
 
-    __slots__ = ("_chunk_size", "_cr_uid", "_ids", "_it", "_logger", "_model", "_patch", "_size", "_strategy")
+    __slots__ = (
+        "_chunk_size",
+        "_cr_uid",
+        "_ids",
+        "_it",
+        "_logger",
+        "_model",
+        "_patch",
+        "_size",
+        "_strategy",
+        "_task_size",
+    )
 
     def __init__(self, model, *args, **kw):
         assert len(args) in [1, 3]  # either (cr, uid, ids) or (ids,)
@@ -400,7 +441,28 @@ 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 not ProcessPoolExecutor:
+                raise ValueError("multiprocessing mode can not be used in scripts run by python2")
+            if UPG_PARALLEL_ITER_BROWSE:
+                self._task_size = self._chunk_size
+                self._chunk_size = min(get_max_workers() * 10 * self._task_size, 1000000)
+            else:
+                self._strategy = "commit"  # downgrade
+                if 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,
+                    )
+                else:
+                    _logger.info(
+                        "Caller requested multiprocessing strategy, but UPG_PARALLEL_ITER_BROWSE env var is not set. "
+                        "Downgrading strategy to commit.",
+                    )
         if kw:
             raise TypeError("Unknown arguments: %s" % ", ".join(kw))
 
@@ -447,7 +509,7 @@ 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()
         else:
             flush(self._model)
@@ -482,6 +544,31 @@ def __getattr__(self, attr):
 
         def caller(*args, **kwargs):
             args = self._cr_uid + args
+            if self._strategy == "multiprocessing":
+                params = {
+                    "dbname": self._model.env.cr.dbname,
+                    "model_name": self._model._name,
+                    # convert to dict for pickle. Will still break if any value in the context is not pickleable
+                    "context": dict(self._model.env.context),
+                    "attr_name": attr,
+                    "args": args,
+                    "kwargs": kwargs,
+                    "mode": "browse",
+                }
+                self._model.env.cr.commit()
+                extrakwargs = {"mp_context": multiprocessing.get_context("fork")} if sys.version_info >= (3, 7) else {}
+                with ProcessPoolExecutor(max_workers=get_max_workers(), **extrakwargs) as executor:
+                    for chunk in it:
+                        collections.deque(
+                            executor.map(
+                                _mp_iter_browse_cb, chunks(chunk._ids, self._task_size, fmt=tuple), repeat(params)
+                            ),
+                            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