This is an archive of the discontinued Mercurial Phabricator instance.

Differential D579

revset: do not flip "and" arguments when optimizing
ClosedPublic

Authored by quark on Aug 30 2017, 7:12 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG37b82485097f: revset: do not flip "and" arguments when optimizing
Summary

Rewrite flipand(y, x) to andsmally(x, y) so the AST order is unchanged,
which could be more friendly to developers.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

quark created this revision.Aug 30 2017, 7:12 PM
Closed by commit rHG37b82485097f: revset: do not flip "and" arguments when optimizing (authored by quark). · Explain WhyAug 31 2017, 1:50 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mmercurial/revset.py (6 lines)
Mmercurial/revsetlang.py (2 lines)
Mtests/test-revset.t (52 lines)

Diff 1467

mercurial/revset.py

def andset(repo, subset, x, y, order): def andset(repo, subset, x, y, order):
if order == anyorder: if order == anyorder:
yorder = anyorder yorder = anyorder
else: else:
yorder = followorder yorder = followorder
return getset(repo, getset(repo, subset, x, order), y, yorder) return getset(repo, getset(repo, subset, x, order), y, yorder)
def flipandset(repo, subset, y, x, order): def andsmallyset(repo, subset, x, y, order):
# 'flipand(y, x)' is equivalent to 'and(x, y)', but faster when y is small # 'andsmally(x, y)' is equivalent to 'and(x, y)', but faster when y is small
if order == anyorder: if order == anyorder:
yorder = anyorder yorder = anyorder
else: else:
yorder = followorder yorder = followorder
return getset(repo, getset(repo, subset, y, yorder), x, order) return getset(repo, getset(repo, subset, y, yorder), x, order)
def differenceset(repo, subset, x, y, order): def differenceset(repo, subset, x, y, order):
return getset(repo, subset, x, order) - getset(repo, subset, y, anyorder) return getset(repo, subset, x, order) - getset(repo, subset, y, anyorder)
"range": rangeset, "range": rangeset,
"rangeall": rangeall, "rangeall": rangeall,
"rangepre": rangepre, "rangepre": rangepre,
"rangepost": rangepost, "rangepost": rangepost,
"dagrange": dagrange, "dagrange": dagrange,
"string": stringset, "string": stringset,
"symbol": stringset, "symbol": stringset,
"and": andset, "and": andset,
"flipand": flipandset, "andsmally": andsmallyset,
"or": orset, "or": orset,
"not": notset, "not": notset,
"difference": differenceset, "difference": differenceset,
"relation": relationset, "relation": relationset,
"relsubscript": relsubscriptset, "relsubscript": relsubscriptset,
"subscript": subscriptset, "subscript": subscriptset,
"list": listset, "list": listset,
"keyvalue": keyvaluepair, "keyvalue": keyvaluepair,

mercurial/revsetlang.py

# (::x and not ::y)/(not ::y and ::x) have a fast path # (::x and not ::y)/(not ::y and ::x) have a fast path
tm = _matchonly(ta, tb) or _matchonly(tb, ta) tm = _matchonly(ta, tb) or _matchonly(tb, ta)
if tm: if tm:
return w, ('func', ('symbol', 'only'), tm) return w, ('func', ('symbol', 'only'), tm)
if tb is not None and tb[0] == 'not': if tb is not None and tb[0] == 'not':
return wa, ('difference', ta, tb[1]) return wa, ('difference', ta, tb[1])
if wa > wb: if wa > wb:
return w, ('flipand', tb, ta) op = 'andsmally'
return w, (op, ta, tb) return w, (op, ta, tb)
elif op == 'or': elif op == 'or':
# fast path for machine-generated expression, that is likely to have # fast path for machine-generated expression, that is likely to have
# lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()' # lots of trivial revisions: 'a + b + c()' to '_list(a b) + c()'
ws, ts, ss = [], [], [] ws, ts, ss = [], [], []
def flushss(): def flushss():
if not ss: if not ss:
return return

tests/test-revset.t

$ hg debugrevspec --verify -v -p analyzed -p optimized 'r3232() & 2' $ hg debugrevspec --verify -v -p analyzed -p optimized 'r3232() & 2'
* analyzed: * analyzed:
(and (and
(func (func
('symbol', 'r3232') ('symbol', 'r3232')
None) None)
('symbol', '2')) ('symbol', '2'))
* optimized: * optimized:
(flipand (andsmally
('symbol', '2')
(func (func
('symbol', 'r3232') ('symbol', 'r3232')
None)) None)
('symbol', '2'))
* analyzed set: * analyzed set:
<baseset [2]> <baseset [2]>
* optimized set: * optimized set:
<baseset [2, 2]> <baseset [2, 2]>
--- analyzed --- analyzed
+++ optimized +++ optimized
2 2
+2 +2
(and (and
(range (range
('symbol', '2') ('symbol', '2')
('symbol', '0')) ('symbol', '0'))
(func (func
('symbol', '_intlist') ('symbol', '_intlist')
('string', '0\x001\x002'))) ('string', '0\x001\x002')))
* optimized: * optimized:
(flipand (andsmally
(func
('symbol', '_intlist')
('string', '0\x001\x002'))
(range (range
('symbol', '2') ('symbol', '2')
('symbol', '0'))) ('symbol', '0'))
(func
('symbol', '_intlist')
('string', '0\x001\x002')))
* set: * set:
<filteredset <filteredset
<spanset- 0:3>, <spanset- 0:3>,
<baseset+ [0, 1, 2]>> <baseset+ [0, 1, 2]>>
2 2
1 1
0 0
(and (and
(func (func
('symbol', '_hexlist') ('symbol', '_hexlist')
('string', '*')) (glob) ('string', '*')) (glob)
(range (range
('symbol', '2') ('symbol', '2')
('symbol', '0'))) ('symbol', '0')))
* optimized: * optimized:
(flipand (andsmally
(range
('symbol', '2')
('symbol', '0'))
(func (func
('symbol', '_hexlist') ('symbol', '_hexlist')
('string', '*'))) (glob) ('string', '*')) (glob)
(range
('symbol', '2')
('symbol', '0')))
* set: * set:
<baseset [0, 2, 1]> <baseset [0, 2, 1]>
0 0
2 2
1 1
'_list' should not go through the slow follow-order path if order doesn't '_list' should not go through the slow follow-order path if order doesn't
matter: matter:
('string', 'glob:*')) ('string', 'glob:*'))
(group (group
(or (or
(list (list
('symbol', '2') ('symbol', '2')
('symbol', '0') ('symbol', '0')
('symbol', '1'))))) ('symbol', '1')))))
* optimized: * optimized:
(flipand (andsmally
(func
('symbol', '_list')
('string', '2\x000\x001'))
(func (func
('symbol', 'contains') ('symbol', 'contains')
('string', 'glob:*'))) ('string', 'glob:*'))
(func
('symbol', '_list')
('string', '2\x000\x001')))
* set: * set:
<filteredset <filteredset
<baseset+ [0, 1, 2]>, <baseset+ [0, 1, 2]>,
<contains 'glob:*'>> <contains 'glob:*'>>
0 0
1 1
2 2
('string', 'glob:*'))) ('string', 'glob:*')))
(group (group
(or (or
(list (list
('symbol', '0') ('symbol', '0')
('symbol', '2') ('symbol', '2')
('symbol', '1'))))) ('symbol', '1')))))
* optimized: * optimized:
(flipand (andsmally
(func
('symbol', '_list')
('string', '0\x002\x001'))
(func (func
('symbol', 'reverse') ('symbol', 'reverse')
(func (func
('symbol', 'contains') ('symbol', 'contains')
('string', 'glob:*')))) ('string', 'glob:*')))
(func
('symbol', '_list')
('string', '0\x002\x001')))
* set: * set:
<filteredset <filteredset
<baseset- [0, 1, 2]>, <baseset- [0, 1, 2]>,
<contains 'glob:*'>> <contains 'glob:*'>>
2 2
1 1
0 0
$ try --optimize '::1 and ()' $ try --optimize '::1 and ()'
(and (and
(dagrangepre (dagrangepre
('symbol', '1')) ('symbol', '1'))
(group (group
None)) None))
* optimized: * optimized:
(flipand (andsmally
None
(func (func
('symbol', 'ancestors') ('symbol', 'ancestors')
('symbol', '1'))) ('symbol', '1'))
None)
hg: parse error: missing argument hg: parse error: missing argument
[255] [255]
optimization to only() works only if ancestors() takes only one argument optimization to only() works only if ancestors() takes only one argument
$ hg debugrevspec -p optimized 'ancestors(6) - ancestors(4, 1)' $ hg debugrevspec -p optimized 'ancestors(6) - ancestors(4, 1)'
* optimized: * optimized:
(difference (difference