XXX: fix non-determinism

Author: nnethercote

compiler/rustc_middle/src/mir/mono.rs

@@ -3,7 +3,7 @@ use crate::ty::{subst::InternalSubsts, Instance, InstanceDef, SymbolName, TyCtxt
 use rustc_attr::InlineAttr;
 use rustc_data_structures::base_n;
 use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_data_structures::stable_hasher::{Hash128, HashStable, StableHasher};
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
 use rustc_hir::ItemId;
@@ -230,7 +230,7 @@ pub struct CodegenUnit<'tcx> {
     /// contain something unique to this crate (e.g., a module path)
     /// as well as the crate name and disambiguator.
     name: Symbol,
-    items: FxHashMap<MonoItem<'tcx>, (Linkage, Visibility)>,
+    items: FxIndexMap<MonoItem<'tcx>, (Linkage, Visibility)>,
     size_estimate: Option<usize>,
     primary: bool,
     /// True if this is CGU is used to hold code coverage information for dead code,
@@ -291,11 +291,11 @@ impl<'tcx> CodegenUnit<'tcx> {
         self.primary = true;
     }
 
-    pub fn items(&self) -> &FxHashMap<MonoItem<'tcx>, (Linkage, Visibility)> {
+    pub fn items(&self) -> &FxIndexMap<MonoItem<'tcx>, (Linkage, Visibility)> {
         &self.items
     }
 
-    pub fn items_mut(&mut self) -> &mut FxHashMap<MonoItem<'tcx>, (Linkage, Visibility)> {
+    pub fn items_mut(&mut self) -> &mut FxIndexMap<MonoItem<'tcx>, (Linkage, Visibility)> {
         &mut self.items
     }
 
@@ -364,6 +364,47 @@ impl<'tcx> CodegenUnit<'tcx> {
             .unwrap_or_else(|| panic!("Could not find work-product for CGU `{}`", self.name()))
     }
 
+    // njn: dups code in items_in_deterministic_order
+    pub fn sort_items(&mut self, tcx: TyCtxt<'tcx>) {
+        // The codegen tests rely on items being process in the same order as
+        // they appear in the file, so for local items, we sort by node_id first
+        #[derive(PartialEq, Eq, PartialOrd, Ord)]
+        pub struct ItemSortKey<'tcx>(Option<usize>, SymbolName<'tcx>);
+
+        fn item_sort_key<'tcx>(tcx: TyCtxt<'tcx>, item: MonoItem<'tcx>) -> ItemSortKey<'tcx> {
+            ItemSortKey(
+                match item {
+                    MonoItem::Fn(ref instance) => {
+                        match instance.def {
+                            // We only want to take HirIds of user-defined
+                            // instances into account. The others don't matter for
+                            // the codegen tests and can even make item order
+                            // unstable.
+                            InstanceDef::Item(def) => def.as_local().map(Idx::index),
+                            InstanceDef::VTableShim(..)
+                            | InstanceDef::ReifyShim(..)
+                            | InstanceDef::Intrinsic(..)
+                            | InstanceDef::FnPtrShim(..)
+                            | InstanceDef::Virtual(..)
+                            | InstanceDef::ClosureOnceShim { .. }
+                            | InstanceDef::DropGlue(..)
+                            | InstanceDef::CloneShim(..)
+                            | InstanceDef::ThreadLocalShim(..)
+                            | InstanceDef::FnPtrAddrShim(..) => None,
+                        }
+                    }
+                    MonoItem::Static(def_id) => def_id.as_local().map(Idx::index),
+                    MonoItem::GlobalAsm(item_id) => Some(item_id.owner_id.def_id.index()),
+                },
+                item.symbol_name(tcx),
+            )
+        }
+
+        self.items_mut().sort_by(|&i1, _, &i2, _| {
+            std::cmp::Ord::cmp(&item_sort_key(tcx, i1), &item_sort_key(tcx, i2))
+        });
+    }
+
     pub fn items_in_deterministic_order(
         &self,
         tcx: TyCtxt<'tcx>,

compiler/rustc_monomorphize/src/partitioning/default.rs

@@ -148,20 +148,27 @@ impl<'tcx> Partition<'tcx> for DefaultPartitioning {
                     // non-deterministic splitting, which messes up incremental
                     // compilation
 
+                    old_cgu.sort_items(cx.tcx);
+                    while moved_size < target_size {
+                        let (item, rest) = old_cgu.items_mut().pop().unwrap();
+                        moved_size += item.size_estimate(cx.tcx);
+                        new_cgu.items_mut().insert(item, rest);
+                    }
+
                     // njn: nicer way to do this?
                     // njn: don't move if it's the last item
-                    old_cgu.items_mut().drain_filter(|item, rest| {
-                        // njn: true->remove
-                        if moved_size < target_size {
-                            let item_size = item.size_estimate(cx.tcx);
-                            //eprintln!("MOVE: {}", item_size);
-                            moved_size += item_size;
-                            new_cgu.items_mut().insert(*item, *rest);
-                            true
-                        } else {
-                            false
-                        }
-                    });
+                    //old_cgu.items_mut().drain_filter(|item, rest| {
+                    //    // njn: true->remove
+                    //    if moved_size < target_size {
+                    //        let item_size = item.size_estimate(cx.tcx);
+                    //        //eprintln!("MOVE: {}", item_size);
+                    //        moved_size += item_size;
+                    //        new_cgu.items_mut().insert(*item, *rest);
+                    //        true
+                    //    } else {
+                    //        false
+                    //    }
+                    //});
                     new_cgu.increase_size_estimate(moved_size);
                     old_cgu.decrease_size_estimate(moved_size);
 
@@ -193,7 +200,7 @@ impl<'tcx> Partition<'tcx> for DefaultPartitioning {
 
             // Move the mono-items from `cgu_n` to `cgu_n_minus_1`
             cgu_n_minus_1.increase_size_estimate(cgu_n.size_estimate());
-            for (k, v) in cgu_n.items_mut().drain() {
+            for (k, v) in cgu_n.items_mut().drain(..) {
                 cgu_n_minus_1.items_mut().insert(k, v);
             }