Show More
@@ -3228,7 +3228,10 b' def perfrevlogrevision(ui, repo, file_, ' | |||||
3228 | start = r.start |
|
3228 | start = r.start | |
3229 | length = r.length |
|
3229 | length = r.length | |
3230 | inline = r._inline |
|
3230 | inline = r._inline | |
3231 | iosize = r._io.size |
|
3231 | try: | |
|
3232 | iosize = r.index.entry_size | |||
|
3233 | except AttributeError: | |||
|
3234 | iosize = r._io.size | |||
3232 | buffer = util.buffer |
|
3235 | buffer = util.buffer | |
3233 |
|
3236 | |||
3234 | chunks = [] |
|
3237 | chunks = [] |
@@ -15,6 +15,7 b'' | |||||
15 | #include <stddef.h> |
|
15 | #include <stddef.h> | |
16 | #include <stdlib.h> |
|
16 | #include <stdlib.h> | |
17 | #include <string.h> |
|
17 | #include <string.h> | |
|
18 | #include <structmember.h> | |||
18 |
|
19 | |||
19 | #include "bitmanipulation.h" |
|
20 | #include "bitmanipulation.h" | |
20 | #include "charencode.h" |
|
21 | #include "charencode.h" | |
@@ -2866,6 +2867,12 b' static PyGetSetDef index_getset[] = {' | |||||
2866 | {NULL} /* Sentinel */ |
|
2867 | {NULL} /* Sentinel */ | |
2867 | }; |
|
2868 | }; | |
2868 |
|
2869 | |||
|
2870 | static PyMemberDef index_members[] = { | |||
|
2871 | {"entry_size", T_LONG, offsetof(indexObject, hdrsize), 0, | |||
|
2872 | "size of an index entry"}, | |||
|
2873 | {NULL} /* Sentinel */ | |||
|
2874 | }; | |||
|
2875 | ||||
2869 | PyTypeObject HgRevlogIndex_Type = { |
|
2876 | PyTypeObject HgRevlogIndex_Type = { | |
2870 | PyVarObject_HEAD_INIT(NULL, 0) /* header */ |
|
2877 | PyVarObject_HEAD_INIT(NULL, 0) /* header */ | |
2871 | "parsers.index", /* tp_name */ |
|
2878 | "parsers.index", /* tp_name */ | |
@@ -2895,7 +2902,7 b' PyTypeObject HgRevlogIndex_Type = {' | |||||
2895 | 0, /* tp_iter */ |
|
2902 | 0, /* tp_iter */ | |
2896 | 0, /* tp_iternext */ |
|
2903 | 0, /* tp_iternext */ | |
2897 | index_methods, /* tp_methods */ |
|
2904 | index_methods, /* tp_methods */ | |
2898 |
|
|
2905 | index_members, /* tp_members */ | |
2899 | index_getset, /* tp_getset */ |
|
2906 | index_getset, /* tp_getset */ | |
2900 | 0, /* tp_base */ |
|
2907 | 0, /* tp_base */ | |
2901 | 0, /* tp_dict */ |
|
2908 | 0, /* tp_dict */ |
@@ -49,11 +49,13 b' class BaseIndexObject(object):' | |||||
49 | big_int_size = struct.calcsize(b'>Q') |
|
49 | big_int_size = struct.calcsize(b'>Q') | |
50 | # Size of a C long int, platform independent |
|
50 | # Size of a C long int, platform independent | |
51 | int_size = struct.calcsize(b'>i') |
|
51 | int_size = struct.calcsize(b'>i') | |
52 | # Size of the entire index format |
|
|||
53 | index_size = revlog_constants.INDEX_ENTRY_V1.size |
|
|||
54 | # An empty index entry, used as a default value to be overridden, or nullrev |
|
52 | # An empty index entry, used as a default value to be overridden, or nullrev | |
55 | null_item = (0, 0, 0, -1, -1, -1, -1, nullid) |
|
53 | null_item = (0, 0, 0, -1, -1, -1, -1, nullid) | |
56 |
|
54 | |||
|
55 | @util.propertycache | |||
|
56 | def entry_size(self): | |||
|
57 | return self.index_format.size | |||
|
58 | ||||
57 | @property |
|
59 | @property | |
58 | def nodemap(self): |
|
60 | def nodemap(self): | |
59 | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" |
|
61 | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | |
@@ -116,7 +118,7 b' class BaseIndexObject(object):' | |||||
116 | data = self._extra[i - self._lgt] |
|
118 | data = self._extra[i - self._lgt] | |
117 | else: |
|
119 | else: | |
118 | index = self._calculate_index(i) |
|
120 | index = self._calculate_index(i) | |
119 |
data = self._data[index : index + self. |
|
121 | data = self._data[index : index + self.entry_size] | |
120 | r = self.index_format.unpack(data) |
|
122 | r = self.index_format.unpack(data) | |
121 | if self._lgt and i == 0: |
|
123 | if self._lgt and i == 0: | |
122 | r = (offset_type(0, gettype(r[0])),) + r[1:] |
|
124 | r = (offset_type(0, gettype(r[0])),) + r[1:] | |
@@ -125,13 +127,13 b' class BaseIndexObject(object):' | |||||
125 |
|
127 | |||
126 | class IndexObject(BaseIndexObject): |
|
128 | class IndexObject(BaseIndexObject): | |
127 | def __init__(self, data): |
|
129 | def __init__(self, data): | |
128 |
assert len(data) % self. |
|
130 | assert len(data) % self.entry_size == 0 | |
129 | self._data = data |
|
131 | self._data = data | |
130 |
self._lgt = len(data) // self. |
|
132 | self._lgt = len(data) // self.entry_size | |
131 | self._extra = [] |
|
133 | self._extra = [] | |
132 |
|
134 | |||
133 | def _calculate_index(self, i): |
|
135 | def _calculate_index(self, i): | |
134 |
return i * self. |
|
136 | return i * self.entry_size | |
135 |
|
137 | |||
136 | def __delitem__(self, i): |
|
138 | def __delitem__(self, i): | |
137 | if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: |
|
139 | if not isinstance(i, slice) or not i.stop == -1 or i.step is not None: | |
@@ -140,7 +142,7 b' class IndexObject(BaseIndexObject):' | |||||
140 | self._check_index(i) |
|
142 | self._check_index(i) | |
141 | self._stripnodes(i) |
|
143 | self._stripnodes(i) | |
142 | if i < self._lgt: |
|
144 | if i < self._lgt: | |
143 |
self._data = self._data[: i * self. |
|
145 | self._data = self._data[: i * self.entry_size] | |
144 | self._lgt = i |
|
146 | self._lgt = i | |
145 | self._extra = [] |
|
147 | self._extra = [] | |
146 | else: |
|
148 | else: | |
@@ -203,7 +205,7 b' class InlinedIndexObject(BaseIndexObject' | |||||
203 | if lgt is not None: |
|
205 | if lgt is not None: | |
204 | self._offsets = [0] * lgt |
|
206 | self._offsets = [0] * lgt | |
205 | count = 0 |
|
207 | count = 0 | |
206 |
while off <= len(self._data) - self. |
|
208 | while off <= len(self._data) - self.entry_size: | |
207 | start = off + self.big_int_size |
|
209 | start = off + self.big_int_size | |
208 | (s,) = struct.unpack( |
|
210 | (s,) = struct.unpack( | |
209 | b'>i', |
|
211 | b'>i', | |
@@ -212,7 +214,7 b' class InlinedIndexObject(BaseIndexObject' | |||||
212 | if lgt is not None: |
|
214 | if lgt is not None: | |
213 | self._offsets[count] = off |
|
215 | self._offsets[count] = off | |
214 | count += 1 |
|
216 | count += 1 | |
215 |
off += self. |
|
217 | off += self.entry_size + s | |
216 | if off != len(self._data): |
|
218 | if off != len(self._data): | |
217 | raise ValueError(b"corrupted data") |
|
219 | raise ValueError(b"corrupted data") | |
218 | return count |
|
220 | return count | |
@@ -244,7 +246,6 b' def parse_index2(data, inline, revlogv2=' | |||||
244 |
|
246 | |||
245 | class Index2Mixin(object): |
|
247 | class Index2Mixin(object): | |
246 | index_format = revlog_constants.INDEX_ENTRY_V2 |
|
248 | index_format = revlog_constants.INDEX_ENTRY_V2 | |
247 | index_size = revlog_constants.INDEX_ENTRY_V2.size |
|
|||
248 | null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0) |
|
249 | null_item = (0, 0, 0, -1, -1, -1, -1, nullid, 0, 0) | |
249 |
|
250 | |||
250 | def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): |
|
251 | def replace_sidedata_info(self, i, sidedata_offset, sidedata_length): | |
@@ -280,7 +281,7 b' class InlinedIndexObject2(Index2Mixin, I' | |||||
280 | if lgt is not None: |
|
281 | if lgt is not None: | |
281 | self._offsets = [0] * lgt |
|
282 | self._offsets = [0] * lgt | |
282 | count = 0 |
|
283 | count = 0 | |
283 |
while off <= len(self._data) - self. |
|
284 | while off <= len(self._data) - self.entry_size: | |
284 | start = off + self.big_int_size |
|
285 | start = off + self.big_int_size | |
285 | (data_size,) = struct.unpack( |
|
286 | (data_size,) = struct.unpack( | |
286 | b'>i', |
|
287 | b'>i', | |
@@ -293,7 +294,7 b' class InlinedIndexObject2(Index2Mixin, I' | |||||
293 | if lgt is not None: |
|
294 | if lgt is not None: | |
294 | self._offsets[count] = off |
|
295 | self._offsets[count] = off | |
295 | count += 1 |
|
296 | count += 1 | |
296 |
off += self. |
|
297 | off += self.entry_size + data_size + side_data_size | |
297 | if off != len(self._data): |
|
298 | if off != len(self._data): | |
298 | raise ValueError(b"corrupted data") |
|
299 | raise ValueError(b"corrupted data") | |
299 | return count |
|
300 | return count |
@@ -222,6 +222,8 b' class revlogproblem(object):' | |||||
222 |
|
222 | |||
223 |
|
223 | |||
224 | class revlogoldindex(list): |
|
224 | class revlogoldindex(list): | |
|
225 | entry_size = INDEX_ENTRY_V0.size | |||
|
226 | ||||
225 | @property |
|
227 | @property | |
226 | def nodemap(self): |
|
228 | def nodemap(self): | |
227 | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" |
|
229 | msg = b"index.nodemap is deprecated, use index.[has_node|rev|get_rev]" | |
@@ -273,11 +275,8 b' class revlogoldindex(list):' | |||||
273 |
|
275 | |||
274 |
|
276 | |||
275 | class revlogoldio(object): |
|
277 | class revlogoldio(object): | |
276 | def __init__(self): |
|
|||
277 | self.size = INDEX_ENTRY_V0.size |
|
|||
278 |
|
||||
279 | def parseindex(self, data, inline): |
|
278 | def parseindex(self, data, inline): | |
280 |
s = |
|
279 | s = INDEX_ENTRY_V0.size | |
281 | index = [] |
|
280 | index = [] | |
282 | nodemap = nodemaputil.NodeMap({nullid: nullrev}) |
|
281 | nodemap = nodemaputil.NodeMap({nullid: nullrev}) | |
283 | n = off = 0 |
|
282 | n = off = 0 | |
@@ -334,9 +333,6 b' class revlogoldio(object):' | |||||
334 |
|
333 | |||
335 |
|
334 | |||
336 | class revlogio(object): |
|
335 | class revlogio(object): | |
337 | def __init__(self): |
|
|||
338 | self.size = INDEX_ENTRY_V1.size |
|
|||
339 |
|
||||
340 | def parseindex(self, data, inline): |
|
336 | def parseindex(self, data, inline): | |
341 | # call the C implementation to parse the index data |
|
337 | # call the C implementation to parse the index data | |
342 | index, cache = parsers.parse_index2(data, inline) |
|
338 | index, cache = parsers.parse_index2(data, inline) | |
@@ -350,9 +346,6 b' class revlogio(object):' | |||||
350 |
|
346 | |||
351 |
|
347 | |||
352 | class revlogv2io(object): |
|
348 | class revlogv2io(object): | |
353 | def __init__(self): |
|
|||
354 | self.size = INDEX_ENTRY_V2.size |
|
|||
355 |
|
||||
356 | def parseindex(self, data, inline): |
|
349 | def parseindex(self, data, inline): | |
357 | index, cache = parsers.parse_index2(data, inline, revlogv2=True) |
|
350 | index, cache = parsers.parse_index2(data, inline, revlogv2=True) | |
358 | return index, cache |
|
351 | return index, cache | |
@@ -1716,8 +1709,8 b' class revlog(object):' | |||||
1716 | end = int(iend[0] >> 16) + iend[1] |
|
1709 | end = int(iend[0] >> 16) + iend[1] | |
1717 |
|
1710 | |||
1718 | if self._inline: |
|
1711 | if self._inline: | |
1719 |
start += (startrev + 1) * self. |
|
1712 | start += (startrev + 1) * self.index.entry_size | |
1720 |
end += (endrev + 1) * self. |
|
1713 | end += (endrev + 1) * self.index.entry_size | |
1721 | length = end - start |
|
1714 | length = end - start | |
1722 |
|
1715 | |||
1723 | return start, self._getsegment(start, length, df=df) |
|
1716 | return start, self._getsegment(start, length, df=df) | |
@@ -1751,7 +1744,7 b' class revlog(object):' | |||||
1751 | start = self.start |
|
1744 | start = self.start | |
1752 | length = self.length |
|
1745 | length = self.length | |
1753 | inline = self._inline |
|
1746 | inline = self._inline | |
1754 |
iosize = self. |
|
1747 | iosize = self.index.entry_size | |
1755 | buffer = util.buffer |
|
1748 | buffer = util.buffer | |
1756 |
|
1749 | |||
1757 | l = [] |
|
1750 | l = [] | |
@@ -1979,7 +1972,7 b' class revlog(object):' | |||||
1979 | sidedata_size = index_entry[9] |
|
1972 | sidedata_size = index_entry[9] | |
1980 |
|
1973 | |||
1981 | if self._inline: |
|
1974 | if self._inline: | |
1982 |
sidedata_offset += self. |
|
1975 | sidedata_offset += self.index.entry_size * (1 + rev) | |
1983 | if sidedata_size == 0: |
|
1976 | if sidedata_size == 0: | |
1984 | return {} |
|
1977 | return {} | |
1985 |
|
1978 | |||
@@ -2079,7 +2072,7 b' class revlog(object):' | |||||
2079 | # the temp file replace the real index when we exit the context |
|
2072 | # the temp file replace the real index when we exit the context | |
2080 | # manager |
|
2073 | # manager | |
2081 |
|
2074 | |||
2082 |
tr.replace(self.indexfile, trindex * self. |
|
2075 | tr.replace(self.indexfile, trindex * self.index.entry_size) | |
2083 | nodemaputil.setup_persistent_nodemap(tr, self) |
|
2076 | nodemaputil.setup_persistent_nodemap(tr, self) | |
2084 | self._chunkclear() |
|
2077 | self._chunkclear() | |
2085 |
|
2078 | |||
@@ -2335,12 +2328,12 b' class revlog(object):' | |||||
2335 | # offset is "as if" it were in the .d file, so we need to add on |
|
2328 | # offset is "as if" it were in the .d file, so we need to add on | |
2336 | # the size of the entry metadata. |
|
2329 | # the size of the entry metadata. | |
2337 | self._concurrencychecker( |
|
2330 | self._concurrencychecker( | |
2338 |
ifh, self.indexfile, offset + curr * self. |
|
2331 | ifh, self.indexfile, offset + curr * self.index.entry_size | |
2339 | ) |
|
2332 | ) | |
2340 | else: |
|
2333 | else: | |
2341 | # Entries in the .i are a consistent size. |
|
2334 | # Entries in the .i are a consistent size. | |
2342 | self._concurrencychecker( |
|
2335 | self._concurrencychecker( | |
2343 |
ifh, self.indexfile, curr * self. |
|
2336 | ifh, self.indexfile, curr * self.index.entry_size | |
2344 | ) |
|
2337 | ) | |
2345 | self._concurrencychecker(dfh, self.datafile, offset) |
|
2338 | self._concurrencychecker(dfh, self.datafile, offset) | |
2346 |
|
2339 | |||
@@ -2464,7 +2457,7 b' class revlog(object):' | |||||
2464 | dfh.write(sidedata) |
|
2457 | dfh.write(sidedata) | |
2465 | ifh.write(entry) |
|
2458 | ifh.write(entry) | |
2466 | else: |
|
2459 | else: | |
2467 |
offset += curr * self. |
|
2460 | offset += curr * self.index.entry_size | |
2468 | transaction.add(self.indexfile, offset) |
|
2461 | transaction.add(self.indexfile, offset) | |
2469 | ifh.write(entry) |
|
2462 | ifh.write(entry) | |
2470 | ifh.write(data[0]) |
|
2463 | ifh.write(data[0]) | |
@@ -2502,7 +2495,7 b' class revlog(object):' | |||||
2502 | if r: |
|
2495 | if r: | |
2503 | end = self.end(r - 1) |
|
2496 | end = self.end(r - 1) | |
2504 | ifh = self._indexfp(b"a+") |
|
2497 | ifh = self._indexfp(b"a+") | |
2505 |
isize = r * self. |
|
2498 | isize = r * self.index.entry_size | |
2506 | if self._inline: |
|
2499 | if self._inline: | |
2507 | transaction.add(self.indexfile, end + isize) |
|
2500 | transaction.add(self.indexfile, end + isize) | |
2508 | dfh = None |
|
2501 | dfh = None | |
@@ -2658,9 +2651,9 b' class revlog(object):' | |||||
2658 | end = self.start(rev) |
|
2651 | end = self.start(rev) | |
2659 | if not self._inline: |
|
2652 | if not self._inline: | |
2660 | transaction.add(self.datafile, end) |
|
2653 | transaction.add(self.datafile, end) | |
2661 |
end = rev * self. |
|
2654 | end = rev * self.index.entry_size | |
2662 | else: |
|
2655 | else: | |
2663 |
end += rev * self. |
|
2656 | end += rev * self.index.entry_size | |
2664 |
|
2657 | |||
2665 | transaction.add(self.indexfile, end) |
|
2658 | transaction.add(self.indexfile, end) | |
2666 |
|
2659 | |||
@@ -2699,7 +2692,7 b' class revlog(object):' | |||||
2699 | f.seek(0, io.SEEK_END) |
|
2692 | f.seek(0, io.SEEK_END) | |
2700 | actual = f.tell() |
|
2693 | actual = f.tell() | |
2701 | f.close() |
|
2694 | f.close() | |
2702 |
s = self. |
|
2695 | s = self.index.entry_size | |
2703 | i = max(0, actual // s) |
|
2696 | i = max(0, actual // s) | |
2704 | di = actual - (i * s) |
|
2697 | di = actual - (i * s) | |
2705 | if self._inline: |
|
2698 | if self._inline: | |
@@ -3241,7 +3234,7 b' class revlog(object):' | |||||
3241 |
|
3234 | |||
3242 | # rewrite the new index entries |
|
3235 | # rewrite the new index entries | |
3243 | with self._indexfp(b'w+') as fp: |
|
3236 | with self._indexfp(b'w+') as fp: | |
3244 |
fp.seek(startrev * self. |
|
3237 | fp.seek(startrev * self.index.entry_size) | |
3245 | for i, entry in enumerate(new_entries): |
|
3238 | for i, entry in enumerate(new_entries): | |
3246 | rev = startrev + i |
|
3239 | rev = startrev + i | |
3247 | self.index.replace_sidedata_info(rev, entry[8], entry[9]) |
|
3240 | self.index.replace_sidedata_info(rev, entry[8], entry[9]) |
@@ -12,8 +12,8 b' use crate::{' | |||||
12 | use cpython::{ |
|
12 | use cpython::{ | |
13 | buffer::{Element, PyBuffer}, |
|
13 | buffer::{Element, PyBuffer}, | |
14 | exc::{IndexError, ValueError}, |
|
14 | exc::{IndexError, ValueError}, | |
15 |
ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyModule, |
|
15 | ObjectProtocol, PyBytes, PyClone, PyDict, PyErr, PyInt, PyModule, | |
16 | PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, |
|
16 | PyObject, PyResult, PyString, PyTuple, Python, PythonObject, ToPyObject, | |
17 | }; |
|
17 | }; | |
18 | use hg::{ |
|
18 | use hg::{ | |
19 | nodemap::{Block, NodeMapError, NodeTree}, |
|
19 | nodemap::{Block, NodeMapError, NodeTree}, | |
@@ -285,6 +285,10 b' py_class!(pub class MixedIndex |py| {' | |||||
285 | self.inner_update_nodemap_data(py, docket, nm_data) |
|
285 | self.inner_update_nodemap_data(py, docket, nm_data) | |
286 | } |
|
286 | } | |
287 |
|
287 | |||
|
288 | @property | |||
|
289 | def entry_size(&self) -> PyResult<PyInt> { | |||
|
290 | self.cindex(py).borrow().inner().getattr(py, "entry_size")?.extract::<PyInt>(py) | |||
|
291 | } | |||
288 |
|
292 | |||
289 | }); |
|
293 | }); | |
290 |
|
294 |
General Comments 0
You need to be logged in to leave comments.
Login now