Rev 4786: Change from using little-endian to big-endian everywhere. in http://bazaar.launchpad.net/~jameinel/bzr/chk-index
John Arbash Meinel
john at arbash-meinel.com
Wed Oct 28 03:51:38 GMT 2009
At http://bazaar.launchpad.net/~jameinel/bzr/chk-index
------------------------------------------------------------
revno: 4786
revision-id: john at arbash-meinel.com-20091028035132-bi2w5enkw1bgllbu
parent: john at arbash-meinel.com-20091028033927-mc4axtqvjw2xlml1
committer: John Arbash Meinel <john at arbash-meinel.com>
branch nick: chk-index
timestamp: Tue 2009-10-27 22:51:32 -0500
message:
Change from using little-endian to big-endian everywhere.
In theory this would slow down intel slightly. In practice
I doubt it is a big effect, and it certainly makes
looking at hex-dumps much more understandable. As numbers
show up in hex, rather than some random inverted hex.
(for example, 1000 => 0x03e8 rather than 0xe803).
-------------- next part --------------
=== modified file 'bzrlib/chk_index.py'
--- a/bzrlib/chk_index.py 2009-10-28 03:39:27 +0000
+++ b/bzrlib/chk_index.py 2009-10-28 03:51:32 +0000
@@ -219,7 +219,7 @@
This is based on group_index_start_bytes and group_index_length_bytes
"""
b_to_s = self.bytes_to_struct_format
- self.group_coder = Struct(''.join(['<',
+ self.group_coder = Struct(''.join(['>',
b_to_s(self.group_index_start_bytes),
b_to_s(self.group_index_length_bytes)]))
return self.group_coder
@@ -230,7 +230,7 @@
This is based on mini_index_entry_offset_bytes
"""
b_to_s = self.bytes_to_struct_format
- self.mini_index_coder = Struct(''.join(['<',
+ self.mini_index_coder = Struct(''.join(['>',
b_to_s(self.mini_index_entry_offset_bytes)]))
return self.mini_index_coder
@@ -240,7 +240,7 @@
This is based on entry_hash_bytes and entry_group_offset_bytes.
"""
b_to_s = self.bytes_to_struct_format
- self.entry_coder = Struct(''.join(['<',
+ self.entry_coder = Struct(''.join(['>',
str(self.entry_hash_bytes), 's',
b_to_s(self.entry_group_offset_bytes),
b_to_s(self.entry_group_start_bytes),
=== modified file 'bzrlib/tests/test_chk_index.py'
--- a/bzrlib/tests/test_chk_index.py 2009-10-28 03:39:27 +0000
+++ b/bzrlib/tests/test_chk_index.py 2009-10-28 03:51:32 +0000
@@ -97,20 +97,20 @@
h = builder._build_header()
self.assertEqual(4, h.group_index_start_bytes)
self.assertEqual(4, h.group_index_length_bytes)
- self.assertEqual('<II', h.group_coder.format)
+ self.assertEqual('>II', h.group_coder.format)
bytes = builder._build_group_index(h)
self.assertEqualDiff('\n'.join([
'0000000000000000',
- '0000000000002000',
- '0000200000002000',
- '0000400000002000',
- '0000600000002000',
- '0000800000002000',
- '0000a00000002000',
- '0000c00000002000',
- '0000e00000002000',
- '0000000100002000',
- '0000200100002000',
+ '0000000000200000',
+ '0020000000200000',
+ '0040000000200000',
+ '0060000000200000',
+ '0080000000200000',
+ '00a0000000200000',
+ '00c0000000200000',
+ '00e0000000200000',
+ '0100000000200000',
+ '0120000000200000',
]), '\n'.join([binascii.b2a_hex(b) for b in bytes]))
def test__build_group_bytes_tiny(self):
@@ -121,13 +121,13 @@
h = builder._build_header()
self.assertEqual(2, h.group_index_start_bytes)
self.assertEqual(2, h.group_index_length_bytes)
- self.assertEqual('<HH', h.group_coder.format)
+ self.assertEqual('>HH', h.group_coder.format)
bytes = builder._build_group_index(h)
self.assertEqualDiff('\n'.join([
'00000000',
- '00002909',
- '29098813',
- 'b11c8000',
+ '00000929',
+ '09291388',
+ '1cb10080',
]), '\n'.join([binascii.b2a_hex(b) for b in bytes]))
def test__build_group_bytes_enormous(self):
@@ -137,12 +137,12 @@
h = builder._build_header()
self.assertEqual(8, h.group_index_start_bytes)
self.assertEqual(4, h.group_index_length_bytes)
- self.assertEqual('<QI', h.group_coder.format)
+ self.assertEqual('>QI', h.group_coder.format)
bytes = builder._build_group_index(h)
self.assertEqualDiff('\n'.join([
'000000000000000000000000',
- '000000000000000000008025',
- '000000000000000100008025',
+ '000000000000000025800000',
+ '010000000000000025800000',
]), '\n'.join([binascii.b2a_hex(b) for b in bytes]))
def test__entry_to_bytes(self):
@@ -157,7 +157,7 @@
# For now, these widths are hard-coded
self.assertEqual(1, h.entry_group_start_bytes)
self.assertEqual(1, h.entry_group_length_bytes)
- self.assertEqual('<20sBBB', h.entry_coder.format)
+ self.assertEqual('>20sBBB', h.entry_coder.format)
# (sha_hash, group number, group offset, group length)
self.assertEqual(b2a_hex(self.bit_k1) + '01' '00' '01',
b2a_hex(builder._entry_to_bytes(self.bit_k1, h.entry_coder)))
@@ -232,7 +232,7 @@
h.num_mini_index_entries = 16
h.mini_index_entry_offset_bytes = 2
h._build_mini_index_coder()
- self.assertEqual('<H', h.mini_index_coder.format)
+ self.assertEqual('>H', h.mini_index_coder.format)
mini_index_bytes, entry_bytes = builder._build_mini_index_and_entries(
h)
b2a_hex = binascii.b2a_hex
@@ -245,22 +245,22 @@
'0000',
'0000',
'0000',
- '8400',
- '0000',
- '0000',
- '0000',
- '0000',
- '9d00',
- 'b600',
+ '0084',
+ '0000',
+ '0000',
+ '0000',
+ '0000',
+ '009d',
+ '00b6',
'0000',
]), '\n'.join([b2a_hex(b) for b in mini_index_bytes]))
# bit_k2 < bit_k1
- self.assertEqual('<20sBHH', h.entry_coder.format)
+ self.assertEqual('>20sBHH', h.entry_coder.format)
self.assertEqualDiff('\n'.join([
#hash # Group # start # end/length?
- b2a_hex(self.bit_k2) + '02' '0000' 'e803',
- b2a_hex(self.bit_k1) + '01' '0000' '0100',
- b2a_hex(self.bit_k3) + '02' 'e803' 'f401',
+ b2a_hex(self.bit_k2) + '02' '0000' '03e8',
+ b2a_hex(self.bit_k1) + '01' '0000' '0001',
+ b2a_hex(self.bit_k3) + '02' '03e8' '01f4',
]), '\n'.join([b2a_hex(b) for b in entry_bytes]))
self.assertEqual(0x0084, h.entry_offset)
self.assertEqual(0x009d, h.entry_offset + len(entry_bytes[0]))
@@ -284,13 +284,13 @@
self.assertEqualDiff(
# First the group info
'0000' '0000' # NULL group, probably shouldn't be included
- '0000' 'e803' # group 1 @ offset 0, length 1000
- 'e803' '204e' # group 2 @ offet 1000, length 20000
+ '0000' '03e8' # group 1 @ offset 0, length 1000
+ '03e8' '4e20' # group 2 @ offet 1000, length 20000
'' # No mini index
# 3 entries follow
- + b2a_hex(self.bit_k2) + '02' '0000' 'e803'
- + b2a_hex(self.bit_k1) + '01' '0000' '0100'
- + b2a_hex(self.bit_k3) + '02' 'e803' 'f401'
+ + b2a_hex(self.bit_k2) + '02' '0000' '03e8'
+ + b2a_hex(self.bit_k1) + '01' '0000' '0001'
+ + b2a_hex(self.bit_k3) + '02' '03e8' '01f4'
, b2a_hex(bytes[120:]))
@@ -475,12 +475,12 @@
header = chk_index.CHKIndexHeader()
header.group_index_start_bytes = 1
header.group_index_length_bytes = 1
- self.assertEqual('<BB', header._build_group_coder().format)
+ self.assertEqual('>BB', header._build_group_coder().format)
header.group_index_length_bytes = 2
- self.assertEqual('<BH', header._build_group_coder().format)
+ self.assertEqual('>BH', header._build_group_coder().format)
header.group_index_start_bytes = 4
header.group_index_length_bytes = 4
- self.assertEqual('<II', header._build_group_coder().format)
+ self.assertEqual('>II', header._build_group_coder().format)
# not yet supported
header.group_index_start_bytes = 3
header.group_index_length_bytes = 4
@@ -489,13 +489,13 @@
def test__build_mini_index_coder(self):
header = chk_index.CHKIndexHeader()
header.mini_index_entry_offset_bytes = 4
- self.assertEqual('<I', header._build_mini_index_coder().format)
+ self.assertEqual('>I', header._build_mini_index_coder().format)
header.mini_index_entry_offset_bytes = 2
- self.assertEqual('<H', header._build_mini_index_coder().format)
+ self.assertEqual('>H', header._build_mini_index_coder().format)
header.mini_index_entry_offset_bytes = 4
- self.assertEqual('<I', header._build_mini_index_coder().format)
+ self.assertEqual('>I', header._build_mini_index_coder().format)
header.mini_index_entry_offset_bytes = 8
- self.assertEqual('<Q', header._build_mini_index_coder().format)
+ self.assertEqual('>Q', header._build_mini_index_coder().format)
def test__build_entry_coder(self):
header = chk_index.CHKIndexHeader()
@@ -503,17 +503,17 @@
header.entry_group_offset_bytes = 2
header.entry_group_start_bytes = 4
header.entry_group_length_bytes = 4
- self.assertEqual('<20sHII', header._build_entry_coder().format)
+ self.assertEqual('>20sHII', header._build_entry_coder().format)
header.entry_hash_bytes = 19
header.entry_group_offset_bytes = 4
header.entry_group_start_bytes = 4
header.entry_group_length_bytes = 4
- self.assertEqual('<19sIII', header._build_entry_coder().format)
+ self.assertEqual('>19sIII', header._build_entry_coder().format)
header.entry_hash_bytes = 19
header.entry_group_offset_bytes = 1
header.entry_group_start_bytes = 2
header.entry_group_length_bytes = 2
- self.assertEqual('<19sBHH', header._build_entry_coder().format)
+ self.assertEqual('>19sBHH', header._build_entry_coder().format)
def test_build_header_for_medium(self):
header = chk_index.CHKIndexHeader.build_header_for(
More information about the bazaar-commits
mailing list