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