mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c2dd19bc8f
rust/compiler/rustc_serialize/tests/leb128.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

96 lines
3.6 KiB
Rust
Raw Normal View History

Rewrite MemDecoder around pointers not a slice
2023-04-20 22:11:47 -05:00
use rustc_serialize::Decoder;
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
use rustc_serialize::leb128::*;
PR feedback
2024-05-21 19:12:07 -05:00
use rustc_serialize::opaque::{MAGIC_END_BYTES, MemDecoder};
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
macro_rules! impl_test_unsigned_leb128 {
($test_name:ident, $write_fn_name:ident, $read_fn_name:ident, $int_ty:ident) => {
#[test]
fn $test_name() {
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
// Test 256 evenly spaced values of integer range,
// integer max value, and some "random" numbers.
let mut values = Vec::new();
let increment = (1 as $int_ty) << ($int_ty::BITS - 8);
values.extend((0..256).map(|i| $int_ty::MIN + i * increment));
values.push($int_ty::MAX);
values.extend(
(-500..500).map(|i| (i as $int_ty).wrapping_mul(0x12345789ABCDEFu64 as $int_ty)),
);
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
let mut stream = Vec::new();
Reimplement FileEncoder with a small-write optimization
2023-09-04 11:40:08 -05:00
let mut buf = Default::default();
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
for &x in &values {
Reimplement FileEncoder with a small-write optimization
2023-09-04 11:40:08 -05:00
let n = $write_fn_name(&mut buf, x);
stream.extend(&buf[..n]);
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
}
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
let stream_end = stream.len();
PR feedback
2024-05-21 19:12:07 -05:00
stream.extend(MAGIC_END_BYTES);
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
let mut decoder = MemDecoder::new(&stream, 0).unwrap();
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
for &expected in &values {
Rewrite MemDecoder around pointers not a slice
2023-04-20 22:11:47 -05:00
let actual = $read_fn_name(&mut decoder);
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
assert_eq!(expected, actual);
}
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
assert_eq!(stream_end, decoder.position());
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
}
Format the world
2019-12-22 16:42:04 -06:00
};
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
}
impl_test_unsigned_leb128!(test_u16_leb128, write_u16_leb128, read_u16_leb128, u16);
impl_test_unsigned_leb128!(test_u32_leb128, write_u32_leb128, read_u32_leb128, u32);
impl_test_unsigned_leb128!(test_u64_leb128, write_u64_leb128, read_u64_leb128, u64);
impl_test_unsigned_leb128!(test_u128_leb128, write_u128_leb128, read_u128_leb128, u128);
impl_test_unsigned_leb128!(test_usize_leb128, write_usize_leb128, read_usize_leb128, usize);
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
macro_rules! impl_test_signed_leb128 {
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
($test_name:ident, $write_fn_name:ident, $read_fn_name:ident, $int_ty:ident) => {
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
#[test]
fn $test_name() {
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
// Test 256 evenly spaced values of integer range,
// integer max value, and some "random" numbers.
let mut values = Vec::new();
let mut value = $int_ty::MIN;
let increment = (1 as $int_ty) << ($int_ty::BITS - 8);
for _ in 0..256 {
values.push(value);
// The addition in the last loop iteration overflows.
value = value.wrapping_add(increment);
}
values.push($int_ty::MAX);
values.extend(
(-500..500).map(|i| (i as $int_ty).wrapping_mul(0x12345789ABCDEFi64 as $int_ty)),
);
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
let mut stream = Vec::new();
Reimplement FileEncoder with a small-write optimization
2023-09-04 11:40:08 -05:00
let mut buf = Default::default();
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
for &x in &values {
Reimplement FileEncoder with a small-write optimization
2023-09-04 11:40:08 -05:00
let n = $write_fn_name(&mut buf, x);
stream.extend(&buf[..n]);
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
}
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
let stream_end = stream.len();
PR feedback
2024-05-21 19:12:07 -05:00
stream.extend(MAGIC_END_BYTES);
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
let mut decoder = MemDecoder::new(&stream, 0).unwrap();
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
for &expected in &values {
Rewrite MemDecoder around pointers not a slice
2023-04-20 22:11:47 -05:00
let actual = $read_fn_name(&mut decoder);
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
assert_eq!(expected, actual);
}
Add a footer in FileEncoder and check for it in MemDecoder
2024-05-03 20:17:57 -05:00
assert_eq!(stream_end, decoder.position());
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
}
};
libserialize: Unconfigure tests during normal build
2019-07-31 18:47:06 -05:00
}
Serialize incr comp structures to file via fixed-size buffer Reduce a large memory spike that happens during serialization by writing the incr comp structures to file by way of a fixed-size buffer, rather than an unbounded vector. Effort was made to keep the instruction count close to that of the previous implementation. However, buffered writing to a file inherently has more overhead than writing to a vector, because each write may result in a handleable error. To reduce this overhead, arrangements are made so that each LEB128-encoded integer can be written to the buffer with only one capacity and error check. Higher-level optimizations in which entire composite structures can be written with one capacity and error check are possible, but would require much more work. The performance is mostly on par with the previous implementation, with small to moderate instruction count regressions. The memory reduction is significant, however, so it seems like a worth-while trade-off.
2020-12-06 19:30:55 -06:00
rustc_serialize: fix incorrect signed LEB128 decoding The signed LEB128 decoding function used a hardcoded constant of 64 instead of the number of bits in the type of integer being decoded, which resulted in incorrect results for some inputs. Fix this, make the decoding more consistent with the unsigned version, and increase the LEB128 encoding and decoding test coverage.
2020-12-29 17:14:33 -06:00
impl_test_signed_leb128!(test_i16_leb128, write_i16_leb128, read_i16_leb128, i16);
impl_test_signed_leb128!(test_i32_leb128, write_i32_leb128, read_i32_leb128, i32);
impl_test_signed_leb128!(test_i64_leb128, write_i64_leb128, read_i64_leb128, i64);
impl_test_signed_leb128!(test_i128_leb128, write_i128_leb128, read_i128_leb128, i128);
impl_test_signed_leb128!(test_isize_leb128, write_isize_leb128, read_isize_leb128, isize);
Reference in New Issue Copy Permalink