https://github.com/rust-lang/rust http://git.dreamy.place/mirrors/rust/atom?h=perf-tmp 2020-08-30T15:45:07+00:00 2020-08-30T15:45:07+00:00 mark markm@cs.wisc.edu 2020-08-28T03:58:48+00:00 urn:sha1:9e5f7d5631b8f4009ac1c693e585d4b7108d4275 2020-08-19T19:08:35+00:00 Mark Rousskov mark.simulacrum@gmail.com 2020-08-15T23:12:27+00:00 urn:sha1:c8fe232836f7ecf1b1d76d82a91c8d0022be2786 2020-08-15T03:29:12+00:00 pawanbisht62 36775517+pawanbisht62@users.noreply.github.com 2020-08-15T03:29:12+00:00 urn:sha1:bab15885c0ab1230186cc45290c6d6c224289f6b 2020-08-14T16:34:30+00:00 Matthew Jasper mjjasper1@gmail.com 2020-06-11T14:49:57+00:00 urn:sha1:cbcef3effcf64bd0d89ea2dc8973e18d7fcf94c3 - Move the type parameter from `encode` and `decode` methods to the trait. - Remove `UseSpecialized(En|De)codable` traits. - Remove blanket impls for references. - Add `RefDecodable` trait to allow deserializing to arena-allocated references safely. - Remove ability to (de)serialize HIR. - Create proc-macros `(Ty)?(En|De)codable` to help implement these new traits. 2020-08-09T12:28:15+00:00 Mark Rousskov mark.simulacrum@gmail.com 2020-08-09T01:05:50+00:00 urn:sha1:2627eedde97e3e94e786faf8dfe612d65d8a6fa6 Previously if the compiler error'd, fatally, then temporary directories which should be preserved by -Csave-temps would be deleted due to fatal compiler errors being implemented as panics. 2020-08-06T11:26:56+00:00 bishtpawan pawan.bisht@knoldus.com 2020-08-05T11:35:53+00:00 urn:sha1:fdfbd89946ca34d12eec658d111ce9a85cd23df0 2020-05-30T00:05:17+00:00 Josh Stone jistone@redhat.com 2020-05-13T03:09:55+00:00 urn:sha1:6700e186883a83008963d1fdba23eff2b1713e56 This adds new optional methods on `Extend`: `extend_one` add a single element to the collection, and `extend_reserve` pre-allocates space for the predicted number of incoming elements. These are used in `Iterator` for `partition` and `unzip` as they shuffle elements one-at-a-time into their respective collections. 2020-05-10T09:25:00+00:00 Ralf Jung post@ralfj.de 2020-05-09T11:59:21+00:00 urn:sha1:c82103cb21942b171c2fe135d0a32be620113e47 2020-05-07T00:03:23+00:00 bors bors@rust-lang.org 2020-05-07T00:03:23+00:00 urn:sha1:97f3eeec8216d7155c24674b9be55e7c672bcae3 Prevent compiler stack overflow for deeply recursive code I was unable to write a test that 1. runs in under 1s 2. overflows on my machine without this patch The following reproduces the issue, but I don't think it's sensible to include a test that takes 30s to compile. We can now easily squash newly appearing overflows by the strategic insertion of calls to `ensure_sufficient_stack`. ```rust // compile-pass #![recursion_limit="1000000"] macro_rules! chain { (EE $e:expr) => {$e.sin()}; (RECURSE $i:ident $e:expr) => {chain!($i chain!($i chain!($i chain!($i $e))))}; (Z $e:expr) => {chain!(RECURSE EE $e)}; (Y $e:expr) => {chain!(RECURSE Z $e)}; (X $e:expr) => {chain!(RECURSE Y $e)}; (A $e:expr) => {chain!(RECURSE X $e)}; (B $e:expr) => {chain!(RECURSE A $e)}; (C $e:expr) => {chain!(RECURSE B $e)}; // causes overflow on x86_64 linux // less than 1 second until overflow on test machine // after overflow has been fixed, takes 30s to compile :/ (D $e:expr) => {chain!(RECURSE C $e)}; (E $e:expr) => {chain!(RECURSE D $e)}; (F $e:expr) => {chain!(RECURSE E $e)}; // more than 10 seconds (G $e:expr) => {chain!(RECURSE F $e)}; (H $e:expr) => {chain!(RECURSE G $e)}; (I $e:expr) => {chain!(RECURSE H $e)}; (J $e:expr) => {chain!(RECURSE I $e)}; (K $e:expr) => {chain!(RECURSE J $e)}; (L $e:expr) => {chain!(RECURSE L $e)}; } fn main() { let x = chain!(D 42.0_f32); } ``` fixes #55471 fixes #41884 fixes #40161 fixes #34844 fixes #32594 cc @alexcrichton @rust-lang/compiler I looked at all code that checks the recursion limit and inserted stack growth calls where appropriate. 2020-05-05T08:03:13+00:00 Markus Westerlind markus.westerlind@distilnetworks.com 2020-02-24T09:40:36+00:00 urn:sha1:1506b1fc6a42dda3e56789f43587448cc5bf4a36 By merging the undo_log of all structures part of the snapshot the cost of creating a snapshot becomes much cheaper. Since snapshots with no or few changes are so frequent this ends up mattering more than the slight overhead of dispatching on the variants that map to each field.