Mercurial > hg
view mercurial/configitems.py @ 51594:e3a5ec2d236a
outgoing: rework the handling of the `missingroots` case to be faster
The previous implementation was slow, to the point it was taking a significant
amount of `hg bundle --type none-streamv2` call. We rework the code to compute
the same value much faster, making the operation disappear from the `hg bundle
--type none-streamv2` profile. Someone would remark that producing a streamclone
does not requires an `outgoing` object. However that is a matter for another
day. There is other user of `missingroots` (non stream `hg bundle` call for
example), and they will also benefit from this rework.
We implement an old TODO in the process, directly computing the missing and
common attribute as we have most element at hand already.
### benchmark.name = hg.command.bundle
# bin-env-vars.hg.flavor = default
# bin-env-vars.hg.py-re2-module = default
# benchmark.variants.revs = all
# benchmark.variants.type = none-streamv2
## data-env-vars.name = heptapod-public-2024-03-25-zstd-sparse-revlog
before: 7.750458
after: 6.665565 (-14.00%, -1.08)
## data-env-vars.name = mercurial-public-2024-03-22-zstd-sparse-revlog
before: 0.700229
after: 0.496050 (-29.16%, -0.20)
## data-env-vars.name = mozilla-try-2023-03-22-zstd-sparse-revlog
before: 346.508952
after: 316.749699 (-8.59%, -29.76)
## data-env-vars.name = pypy-2024-03-22-zstd-sparse-revlog
before: 3.401700
after: 2.915810 (-14.28%, -0.49)
## data-env-vars.name = tryton-public-2024-03-22-zstd-sparse-revlog
before: 1.870798
after: 1.461583 (-21.87%, -0.41)
note: this whole `missingroots` of outgoing has a limited number of callers and
could likely be replace by something simpler (like taking an explicit
"missing_revs" set for example). However this is a wider change and we focus on
a small impact, quick rework that does not change the API for now.
author | Pierre-Yves David <pierre-yves.david@octobus.net> |
---|---|
date | Tue, 09 Apr 2024 22:36:35 +0200 |
parents | 9c5bd485fbb6 |
children | f4733654f144 |
line wrap: on
line source
# configitems.py - centralized declaration of configuration option # # Copyright 2017 Pierre-Yves David <pierre-yves.david@octobus.net> # # This software may be used and distributed according to the terms of the # GNU General Public License version 2 or any later version. import functools import re from .utils import resourceutil from . import ( encoding, error, ) try: import tomllib # pytype: disable=import-error tomllib.load # trigger lazy import except ModuleNotFoundError: # Python <3.11 compat from .thirdparty import tomli as tomllib def loadconfigtable(ui, extname, configtable): """update config item known to the ui with the extension ones""" for section, items in sorted(configtable.items()): knownitems = ui._knownconfig.setdefault(section, itemregister()) knownkeys = set(knownitems) newkeys = set(items) for key in sorted(knownkeys & newkeys): msg = b"extension '%s' overwrites config item '%s.%s'" msg %= (extname, section, key) ui.develwarn(msg, config=b'warn-config') knownitems.update(items) class configitem: """represent a known config item :section: the official config section where to find this item, :name: the official name within the section, :default: default value for this item, :alias: optional list of tuples as alternatives, :generic: this is a generic definition, match name using regular expression. """ def __init__( self, section, name, default=None, alias=(), generic=False, priority=0, experimental=False, documentation="", in_core_extension=None, ): self.section = section self.name = name self.default = default self.documentation = documentation self.alias = list(alias) self.generic = generic self.priority = priority self.experimental = experimental self._re = None self.in_core_extension = in_core_extension if generic: self._re = re.compile(self.name) class itemregister(dict): """A specialized dictionary that can handle wild-card selection""" def __init__(self): super(itemregister, self).__init__() self._generics = set() def update(self, other): # pytype: disable=signature-mismatch super(itemregister, self).update(other) self._generics.update(other._generics) def __setitem__(self, key, item): super(itemregister, self).__setitem__(key, item) if item.generic: self._generics.add(item) def get(self, key): baseitem = super(itemregister, self).get(key) if baseitem is not None and not baseitem.generic: return baseitem # search for a matching generic item generics = sorted(self._generics, key=(lambda x: (x.priority, x.name))) for item in generics: # we use 'match' instead of 'search' to make the matching simpler # for people unfamiliar with regular expression. Having the match # rooted to the start of the string will produce less surprising # result for user writing simple regex for sub-attribute. # # For example using "color\..*" match produces an unsurprising # result, while using search could suddenly match apparently # unrelated configuration that happens to contains "color." # anywhere. This is a tradeoff where we favor requiring ".*" on # some match to avoid the need to prefix most pattern with "^". # The "^" seems more error prone. if item._re.match(key): return item return None def sanitize_item(item): """Apply the transformations that are encoded on top of the pure data""" # Set the special defaults default_type_key = "default-type" default_type = item.pop(default_type_key, None) if default_type == "dynamic": item["default"] = dynamicdefault elif default_type == "list_type": item["default"] = list elif default_type == "lambda": assert isinstance(item["default"], list) default = [e.encode() for e in item["default"]] item["default"] = lambda: default elif default_type == "lazy_module": item["default"] = lambda: encoding.encoding else: if default_type is not None: msg = "invalid default config type %r for '%s.%s'" msg %= (default_type, item["section"], item["name"]) raise error.ProgrammingError(msg) # config expects bytes alias = item.get("alias") if alias: item["alias"] = [(k.encode(), v.encode()) for (k, v) in alias] if isinstance(item.get("default"), str): item["default"] = item["default"].encode() item["section"] = item["section"].encode() item["name"] = item["name"].encode() def read_configitems_file(): """Returns the deserialized TOML structure from the configitems file""" with resourceutil.open_resource(b"mercurial", b"configitems.toml") as fp: return tomllib.load(fp) def configitems_from_toml(items): """Register the configitems from the *deserialized* toml file""" for item in items["items"]: sanitize_item(item) coreconfigitem(**item) templates = items["templates"] for application in items["template-applications"]: template_items = templates[application["template"]] for template_item in template_items: item = template_item.copy() prefix = application.get("prefix", "") item["section"] = application["section"] if prefix: item["name"] = f'{prefix}.{item["suffix"]}' else: item["name"] = item["suffix"] sanitize_item(item) item.pop("suffix", None) coreconfigitem(**item) def import_configitems_from_file(): as_toml = read_configitems_file() configitems_from_toml(as_toml) coreitems = {} def _register(configtable, *args, **kwargs): item = configitem(*args, **kwargs) section = configtable.setdefault(item.section, itemregister()) if item.name in section: msg = b"duplicated config item registration for '%s.%s'" raise error.ProgrammingError(msg % (item.section, item.name)) section[item.name] = item # special value for case where the default is derived from other values dynamicdefault = object() # Registering actual config items def getitemregister(configtable): f = functools.partial(_register, configtable) # export pseudo enum as configitem.* f.dynamicdefault = dynamicdefault return f coreconfigitem = getitemregister(coreitems) import_configitems_from_file()