https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=1.52.0 2021-03-11T01:53:35+00:00 2021-03-11T01:53:35+00:00 Josh Stone jistone@redhat.com 2021-03-11T01:53:35+00:00 urn:sha1:f7e75a2124ccd8e0a655220f70fd1eba765cf5d2 This pulls in rust-lang/rustc-rayon#8 to fix #81425. (h/t @ammaraskar) That revealed weak constraints on `rustc_arena::DropArena`, because its `DropType` was holding type-erased raw pointers to generic `T`. We can implement `Send` for `DropType` (under `cfg(parallel_compiler)`) by requiring all `T: Send` before they're type-erased. 2021-02-25T23:25:38+00:00 Wesley Wiser wesleywiser@microsoft.com 2021-02-25T23:25:38+00:00 urn:sha1:e130e9cf7787ef83f9cada14b7a2579b09c6a558 This version adds the ability to use `rdpmc` hardware-based performance counters instead of wall-clock time for measuring duration. This also introduces a dependency on the `perf-event-open-sys` crate on Linux which is used when using hardware counters. 2021-02-14T15:03:11+00:00 klensy klensy@users.noreply.github.com 2021-02-14T14:37:30+00:00 urn:sha1:93c8ebe022d0eac6fb02848dc85f003cf7b7503c 2020-10-25T02:39:42+00:00 Wesley Wiser wwiser@gmail.com 2020-10-01T12:34:48+00:00 urn:sha1:5ac5556d63ac03a4d73982ca8cc8287823e876f1 2020-09-22T22:52:07+00:00 bors bors@rust-lang.org 2020-09-22T22:52:07+00:00 urn:sha1:6d3acf5129767db78a3d9d62e814ec86b8870d75 cache types during normalization partially fixes #75992 reduces the following test from 14 to 3 seconds locally. cc `@Mark-Simulacrum` would it make sense to add that test to `perf`? ```rust #![recursion_limit="2048"] #![type_length_limit="112457564"] pub async fn h0(v: &String, x: &u64) { println!("{} {}", v, x) } pub async fn h1(v: &String, x: &u64) { h0(v, x).await } pub async fn h2(v: &String, x: &u64) { h1(v, x).await } pub async fn h3(v: &String, x: &u64) { h2(v, x).await } pub async fn h4(v: &String, x: &u64) { h3(v, x).await } pub async fn h5(v: &String, x: &u64) { h4(v, x).await } pub async fn h6(v: &String, x: &u64) { h5(v, x).await } pub async fn h7(v: &String, x: &u64) { h6(v, x).await } pub async fn h8(v: &String, x: &u64) { h7(v, x).await } pub async fn h9(v: &String, x: &u64) { h8(v, x).await } pub async fn h10(v: &String, x: &u64) { h9(v, x).await } pub async fn h11(v: &String, x: &u64) { h10(v, x).await } pub async fn h12(v: &String, x: &u64) { h11(v, x).await } pub async fn h13(v: &String, x: &u64) { h12(v, x).await } pub async fn h14(v: &String, x: &u64) { h13(v, x).await } pub async fn h15(v: &String, x: &u64) { h14(v, x).await } pub async fn h16(v: &String, x: &u64) { h15(v, x).await } pub async fn h17(v: &String, x: &u64) { h16(v, x).await } pub async fn h18(v: &String, x: &u64) { h17(v, x).await } pub async fn h19(v: &String, x: &u64) { h18(v, x).await } macro_rules! async_recursive { (29, $inner:expr) => { async { async_recursive!(28, $inner) }.await }; (28, $inner:expr) => { async { async_recursive!(27, $inner) }.await }; (27, $inner:expr) => { async { async_recursive!(26, $inner) }.await }; (26, $inner:expr) => { async { async_recursive!(25, $inner) }.await }; (25, $inner:expr) => { async { async_recursive!(24, $inner) }.await }; (24, $inner:expr) => { async { async_recursive!(23, $inner) }.await }; (23, $inner:expr) => { async { async_recursive!(22, $inner) }.await }; (22, $inner:expr) => { async { async_recursive!(21, $inner) }.await }; (21, $inner:expr) => { async { async_recursive!(20, $inner) }.await }; (20, $inner:expr) => { async { async_recursive!(19, $inner) }.await }; (19, $inner:expr) => { async { async_recursive!(18, $inner) }.await }; (18, $inner:expr) => { async { async_recursive!(17, $inner) }.await }; (17, $inner:expr) => { async { async_recursive!(16, $inner) }.await }; (16, $inner:expr) => { async { async_recursive!(15, $inner) }.await }; (15, $inner:expr) => { async { async_recursive!(14, $inner) }.await }; (14, $inner:expr) => { async { async_recursive!(13, $inner) }.await }; (13, $inner:expr) => { async { async_recursive!(12, $inner) }.await }; (12, $inner:expr) => { async { async_recursive!(11, $inner) }.await }; (11, $inner:expr) => { async { async_recursive!(10, $inner) }.await }; (10, $inner:expr) => { async { async_recursive!(9, $inner) }.await }; (9, $inner:expr) => { async { async_recursive!(8, $inner) }.await }; (8, $inner:expr) => { async { async_recursive!(7, $inner) }.await }; (7, $inner:expr) => { async { async_recursive!(6, $inner) }.await }; (6, $inner:expr) => { async { async_recursive!(5, $inner) }.await }; (5, $inner:expr) => { async { async_recursive!(4, $inner) }.await }; (4, $inner:expr) => { async { async_recursive!(3, $inner) }.await }; (3, $inner:expr) => { async { async_recursive!(2, $inner) }.await }; (2, $inner:expr) => { async { async_recursive!(1, $inner) }.await }; (1, $inner:expr) => { async { async_recursive!(0, $inner) }.await }; (0, $inner:expr) => { async { h19(&String::from("owo"), &0).await; $inner }.await }; } async fn f() { async_recursive!(14, println!("hello")); } fn main() { let _ = f(); } ``` r? `@eddyb` requires a perf run. 2020-09-20T17:07:52+00:00 Julian Wollersberger julian.wollersberger@gmx.at 2020-09-20T17:07:52+00:00 urn:sha1:53aaa1e532657390edfbe046a3f18d95e9543424 2020-09-19T15:27:13+00:00 Bastian Kauschke bastian_kauschke@hotmail.de 2020-09-19T15:27:13+00:00 urn:sha1:1146c39da74b3875e6667aeeafde2773644dc8b6 2020-09-12T06:26:53+00:00 Andreas Jonson andjo403@users.noreply.github.com 2020-09-12T06:24:09+00:00 urn:sha1:b8752fff19fdf5d6b821eefe1cf6709d4cad8cdf this is to avoid compiling multiple version of the crates in rustc 2020-09-01T21:06:47+00:00 marmeladema xademax@gmail.com 2020-08-30T10:48:50+00:00 urn:sha1:1b650d0fea209e0b69407a0a1e04feeb57c4b2d4 2020-08-30T19:06:14+00:00 marmeladema xademax@gmail.com 2020-08-29T18:16:49+00:00 urn:sha1:68500ffacb4d28586a9c17799ab73e41aa2cfe94