Skip to content

Commit a99ae95

Browse files
borsbors
committed
Auto merge of #75060 - JohnTitor:rollup-aq8sfxf, r=JohnTitor
Rollup of 10 pull requests Successful merges: - #74686 (BTreeMap: remove into_slices and its unsafe block) - #74762 (BTreeMap::drain_filter should not touch the root during iteration) - #74781 (Clean up E0733 explanation) - #74874 (BTreeMap: define forget_type only when relevant) - #74974 (Make tests faster in Miri) - #75010 (Update elasticlunr-rs and ammonia transitive deps) - #75041 (Replaced log with tracing crate) - #75044 (Clean up E0744 explanation) - #75054 (Rename rustc_middle::cstore::DepKind to CrateDepKind) - #75057 (Avoid dumping rustc invocations to stdout) Failed merges: - #74827 (Move bulk of BTreeMap::insert method down to new method on handle) r? @ghost
2 parents e8876ae + 50f2b5d commit a99ae95

File tree

30 files changed

+642
-350
lines changed

30 files changed

+642
-350
lines changed

‎Cargo.lock

+140-215
Large diffs are not rendered by default.

‎library/alloc/benches/btree/map.rs

+302
Original file line numberDiff line numberDiff line change
@@ -282,3 +282,305 @@ pub fn iter_10k(b: &mut Bencher) {
282282
pub fn iter_1m(b: &mut Bencher) {
283283
bench_iter(b, 1_000, 1_000_000);
284284
}
285+
286+
const FAT: usize = 256;
287+
288+
// The returned map has small keys and values.
289+
// Benchmarks on it have a counterpart in set.rs with the same keys and no values at all.
290+
fn slim_map(n: usize) -> BTreeMap<usize, usize> {
291+
(0..n).map(|i| (i, i)).collect::<BTreeMap<_, _>>()
292+
}
293+
294+
// The returned map has small keys and large values.
295+
fn fat_val_map(n: usize) -> BTreeMap<usize, [usize; FAT]> {
296+
(0..n).map(|i| (i, [i; FAT])).collect::<BTreeMap<_, _>>()
297+
}
298+
299+
// The returned map has large keys and values.
300+
fn fat_map(n: usize) -> BTreeMap<[usize; FAT], [usize; FAT]> {
301+
(0..n).map(|i| ([i; FAT], [i; FAT])).collect::<BTreeMap<_, _>>()
302+
}
303+
304+
#[bench]
305+
pub fn clone_slim_100(b: &mut Bencher) {
306+
let src = slim_map(100);
307+
b.iter(|| src.clone())
308+
}
309+
310+
#[bench]
311+
pub fn clone_slim_100_and_clear(b: &mut Bencher) {
312+
let src = slim_map(100);
313+
b.iter(|| src.clone().clear())
314+
}
315+
316+
#[bench]
317+
pub fn clone_slim_100_and_drain_all(b: &mut Bencher) {
318+
let src = slim_map(100);
319+
b.iter(|| src.clone().drain_filter(|_, _| true).count())
320+
}
321+
322+
#[bench]
323+
pub fn clone_slim_100_and_drain_half(b: &mut Bencher) {
324+
let src = slim_map(100);
325+
b.iter(|| {
326+
let mut map = src.clone();
327+
assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2);
328+
assert_eq!(map.len(), 100 / 2);
329+
})
330+
}
331+
332+
#[bench]
333+
pub fn clone_slim_100_and_into_iter(b: &mut Bencher) {
334+
let src = slim_map(100);
335+
b.iter(|| src.clone().into_iter().count())
336+
}
337+
338+
#[bench]
339+
pub fn clone_slim_100_and_pop_all(b: &mut Bencher) {
340+
let src = slim_map(100);
341+
b.iter(|| {
342+
let mut map = src.clone();
343+
while map.pop_first().is_some() {}
344+
map
345+
});
346+
}
347+
348+
#[bench]
349+
pub fn clone_slim_100_and_remove_all(b: &mut Bencher) {
350+
let src = slim_map(100);
351+
b.iter(|| {
352+
let mut map = src.clone();
353+
while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
354+
let v = map.remove(&elt);
355+
debug_assert!(v.is_some());
356+
}
357+
map
358+
});
359+
}
360+
361+
#[bench]
362+
pub fn clone_slim_100_and_remove_half(b: &mut Bencher) {
363+
let src = slim_map(100);
364+
b.iter(|| {
365+
let mut map = src.clone();
366+
for i in (0..100).step_by(2) {
367+
let v = map.remove(&i);
368+
debug_assert!(v.is_some());
369+
}
370+
assert_eq!(map.len(), 100 / 2);
371+
map
372+
})
373+
}
374+
375+
#[bench]
376+
pub fn clone_slim_10k(b: &mut Bencher) {
377+
let src = slim_map(10_000);
378+
b.iter(|| src.clone())
379+
}
380+
381+
#[bench]
382+
pub fn clone_slim_10k_and_clear(b: &mut Bencher) {
383+
let src = slim_map(10_000);
384+
b.iter(|| src.clone().clear())
385+
}
386+
387+
#[bench]
388+
pub fn clone_slim_10k_and_drain_all(b: &mut Bencher) {
389+
let src = slim_map(10_000);
390+
b.iter(|| src.clone().drain_filter(|_, _| true).count())
391+
}
392+
393+
#[bench]
394+
pub fn clone_slim_10k_and_drain_half(b: &mut Bencher) {
395+
let src = slim_map(10_000);
396+
b.iter(|| {
397+
let mut map = src.clone();
398+
assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 10_000 / 2);
399+
assert_eq!(map.len(), 10_000 / 2);
400+
})
401+
}
402+
403+
#[bench]
404+
pub fn clone_slim_10k_and_into_iter(b: &mut Bencher) {
405+
let src = slim_map(10_000);
406+
b.iter(|| src.clone().into_iter().count())
407+
}
408+
409+
#[bench]
410+
pub fn clone_slim_10k_and_pop_all(b: &mut Bencher) {
411+
let src = slim_map(10_000);
412+
b.iter(|| {
413+
let mut map = src.clone();
414+
while map.pop_first().is_some() {}
415+
map
416+
});
417+
}
418+
419+
#[bench]
420+
pub fn clone_slim_10k_and_remove_all(b: &mut Bencher) {
421+
let src = slim_map(10_000);
422+
b.iter(|| {
423+
let mut map = src.clone();
424+
while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
425+
let v = map.remove(&elt);
426+
debug_assert!(v.is_some());
427+
}
428+
map
429+
});
430+
}
431+
432+
#[bench]
433+
pub fn clone_slim_10k_and_remove_half(b: &mut Bencher) {
434+
let src = slim_map(10_000);
435+
b.iter(|| {
436+
let mut map = src.clone();
437+
for i in (0..10_000).step_by(2) {
438+
let v = map.remove(&i);
439+
debug_assert!(v.is_some());
440+
}
441+
assert_eq!(map.len(), 10_000 / 2);
442+
map
443+
})
444+
}
445+
446+
#[bench]
447+
pub fn clone_fat_val_100(b: &mut Bencher) {
448+
let src = fat_val_map(100);
449+
b.iter(|| src.clone())
450+
}
451+
452+
#[bench]
453+
pub fn clone_fat_val_100_and_clear(b: &mut Bencher) {
454+
let src = fat_val_map(100);
455+
b.iter(|| src.clone().clear())
456+
}
457+
458+
#[bench]
459+
pub fn clone_fat_val_100_and_drain_all(b: &mut Bencher) {
460+
let src = fat_val_map(100);
461+
b.iter(|| src.clone().drain_filter(|_, _| true).count())
462+
}
463+
464+
#[bench]
465+
pub fn clone_fat_val_100_and_drain_half(b: &mut Bencher) {
466+
let src = fat_val_map(100);
467+
b.iter(|| {
468+
let mut map = src.clone();
469+
assert_eq!(map.drain_filter(|i, _| i % 2 == 0).count(), 100 / 2);
470+
assert_eq!(map.len(), 100 / 2);
471+
})
472+
}
473+
474+
#[bench]
475+
pub fn clone_fat_val_100_and_into_iter(b: &mut Bencher) {
476+
let src = fat_val_map(100);
477+
b.iter(|| src.clone().into_iter().count())
478+
}
479+
480+
#[bench]
481+
pub fn clone_fat_val_100_and_pop_all(b: &mut Bencher) {
482+
let src = fat_val_map(100);
483+
b.iter(|| {
484+
let mut map = src.clone();
485+
while map.pop_first().is_some() {}
486+
map
487+
});
488+
}
489+
490+
#[bench]
491+
pub fn clone_fat_val_100_and_remove_all(b: &mut Bencher) {
492+
let src = fat_val_map(100);
493+
b.iter(|| {
494+
let mut map = src.clone();
495+
while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
496+
let v = map.remove(&elt);
497+
debug_assert!(v.is_some());
498+
}
499+
map
500+
});
501+
}
502+
503+
#[bench]
504+
pub fn clone_fat_val_100_and_remove_half(b: &mut Bencher) {
505+
let src = fat_val_map(100);
506+
b.iter(|| {
507+
let mut map = src.clone();
508+
for i in (0..100).step_by(2) {
509+
let v = map.remove(&i);
510+
debug_assert!(v.is_some());
511+
}
512+
assert_eq!(map.len(), 100 / 2);
513+
map
514+
})
515+
}
516+
517+
#[bench]
518+
pub fn clone_fat_100(b: &mut Bencher) {
519+
let src = fat_map(100);
520+
b.iter(|| src.clone())
521+
}
522+
523+
#[bench]
524+
pub fn clone_fat_100_and_clear(b: &mut Bencher) {
525+
let src = fat_map(100);
526+
b.iter(|| src.clone().clear())
527+
}
528+
529+
#[bench]
530+
pub fn clone_fat_100_and_drain_all(b: &mut Bencher) {
531+
let src = fat_map(100);
532+
b.iter(|| src.clone().drain_filter(|_, _| true).count())
533+
}
534+
535+
#[bench]
536+
pub fn clone_fat_100_and_drain_half(b: &mut Bencher) {
537+
let src = fat_map(100);
538+
b.iter(|| {
539+
let mut map = src.clone();
540+
assert_eq!(map.drain_filter(|i, _| i[0] % 2 == 0).count(), 100 / 2);
541+
assert_eq!(map.len(), 100 / 2);
542+
})
543+
}
544+
545+
#[bench]
546+
pub fn clone_fat_100_and_into_iter(b: &mut Bencher) {
547+
let src = fat_map(100);
548+
b.iter(|| src.clone().into_iter().count())
549+
}
550+
551+
#[bench]
552+
pub fn clone_fat_100_and_pop_all(b: &mut Bencher) {
553+
let src = fat_map(100);
554+
b.iter(|| {
555+
let mut map = src.clone();
556+
while map.pop_first().is_some() {}
557+
map
558+
});
559+
}
560+
561+
#[bench]
562+
pub fn clone_fat_100_and_remove_all(b: &mut Bencher) {
563+
let src = fat_map(100);
564+
b.iter(|| {
565+
let mut map = src.clone();
566+
while let Some(elt) = map.iter().map(|(&i, _)| i).next() {
567+
let v = map.remove(&elt);
568+
debug_assert!(v.is_some());
569+
}
570+
map
571+
});
572+
}
573+
574+
#[bench]
575+
pub fn clone_fat_100_and_remove_half(b: &mut Bencher) {
576+
let src = fat_map(100);
577+
b.iter(|| {
578+
let mut map = src.clone();
579+
for i in (0..100).step_by(2) {
580+
let v = map.remove(&[i; FAT]);
581+
debug_assert!(v.is_some());
582+
}
583+
assert_eq!(map.len(), 100 / 2);
584+
map
585+
})
586+
}

0 commit comments

Comments
 (0)