Give CostChecker both penalties and bonuses

scottmcm · scottmcm · commit f33495103035 · 2024-06-19T21:35:37.000-07:00
diff --git a/compiler/rustc_mir_transform/src/cost_checker.rs b/compiler/rustc_mir_transform/src/cost_checker.rs
@@ -12,7 +12,8 @@ const RESUME_PENALTY: usize = 45;
 pub(crate) struct CostChecker<'b, 'tcx> {
     tcx: TyCtxt<'tcx>,
     param_env: ParamEnv<'tcx>,
-    cost: usize,
+    penalty: usize,
+    bonus: usize,
     callee_body: &'b Body<'tcx>,
     instance: Option<ty::Instance<'tcx>>,
 }
@@ -24,11 +25,11 @@ impl<'b, 'tcx> CostChecker<'b, 'tcx> {
         instance: Option<ty::Instance<'tcx>>,
         callee_body: &'b Body<'tcx>,
     ) -> CostChecker<'b, 'tcx> {
-        CostChecker { tcx, param_env, callee_body, instance, cost: 0 }
+        CostChecker { tcx, param_env, callee_body, instance, penalty: 0, bonus: 0 }
     }
 
     pub fn cost(&self) -> usize {
-        self.cost
+        usize::saturating_sub(self.penalty, self.bonus)
     }
 
     fn instantiate_ty(&self, v: Ty<'tcx>) -> Ty<'tcx> {
@@ -48,7 +49,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
             | StatementKind::StorageDead(_)
             | StatementKind::Deinit(_)
             | StatementKind::Nop => {}
-            _ => self.cost += INSTR_COST,
+            _ => self.penalty += INSTR_COST,
         }
     }
 
@@ -59,17 +60,17 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                 // If the place doesn't actually need dropping, treat it like a regular goto.
                 let ty = self.instantiate_ty(place.ty(self.callee_body, tcx).ty);
                 if ty.needs_drop(tcx, self.param_env) {
-                    self.cost += CALL_PENALTY;
+                    self.penalty += CALL_PENALTY;
                     if let UnwindAction::Cleanup(_) = unwind {
-                        self.cost += LANDINGPAD_PENALTY;
+                        self.penalty += LANDINGPAD_PENALTY;
                     }
                 } else {
-                    self.cost += INSTR_COST;
+                    self.penalty += INSTR_COST;
                 }
             }
             TerminatorKind::Call { func: Operand::Constant(ref f), unwind, .. } => {
                 let fn_ty = self.instantiate_ty(f.const_.ty());
-                self.cost += if let ty::FnDef(def_id, _) = *fn_ty.kind()
+                self.penalty += if let ty::FnDef(def_id, _) = *fn_ty.kind()
                     && tcx.intrinsic(def_id).is_some()
                 {
                     // Don't give intrinsics the extra penalty for calls
@@ -78,23 +79,23 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {
                     CALL_PENALTY
                 };
                 if let UnwindAction::Cleanup(_) = unwind {
-                    self.cost += LANDINGPAD_PENALTY;
+                    self.penalty += LANDINGPAD_PENALTY;
                 }
             }
             TerminatorKind::Assert { unwind, .. } => {
-                self.cost += CALL_PENALTY;
+                self.penalty += CALL_PENALTY;
                 if let UnwindAction::Cleanup(_) = unwind {
-                    self.cost += LANDINGPAD_PENALTY;
+                    self.penalty += LANDINGPAD_PENALTY;
                 }
             }
-            TerminatorKind::UnwindResume => self.cost += RESUME_PENALTY,
+            TerminatorKind::UnwindResume => self.penalty += RESUME_PENALTY,
             TerminatorKind::InlineAsm { unwind, .. } => {
-                self.cost += INSTR_COST;
+                self.penalty += INSTR_COST;
                 if let UnwindAction::Cleanup(_) = unwind {
-                    self.cost += LANDINGPAD_PENALTY;
+                    self.penalty += LANDINGPAD_PENALTY;
                 }
             }
-            _ => self.cost += INSTR_COST,
+            _ => self.penalty += INSTR_COST,
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,8 @@ const RESUME_PENALTY: usize = 45;`
`12`	`12`	`pub(crate) struct CostChecker<'b, 'tcx> {`
`13`	`13`	`tcx: TyCtxt<'tcx>,`
`14`	`14`	`param_env: ParamEnv<'tcx>,`
`15`		`- cost: usize,`
	`15`	`+ penalty: usize,`
	`16`	`+ bonus: usize,`
`16`	`17`	`callee_body: &'b Body<'tcx>,`
`17`	`18`	`instance: Option<ty::Instance<'tcx>>,`
`18`	`19`	`}`
`@@ -24,11 +25,11 @@ impl<'b, 'tcx> CostChecker<'b, 'tcx> {`
`24`	`25`	`instance: Option<ty::Instance<'tcx>>,`
`25`	`26`	`callee_body: &'b Body<'tcx>,`
`26`	`27`	`) -> CostChecker<'b, 'tcx> {`
`27`		`- CostChecker { tcx, param_env, callee_body, instance, cost: 0 }`
	`28`	`+ CostChecker { tcx, param_env, callee_body, instance, penalty: 0, bonus: 0 }`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`pub fn cost(&self) -> usize {`
`31`		`- self.cost`
	`32`	`+ usize::saturating_sub(self.penalty, self.bonus)`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`fn instantiate_ty(&self, v: Ty<'tcx>) -> Ty<'tcx> {`
`@@ -48,7 +49,7 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {`
`48`	`49`	`\| StatementKind::StorageDead(_)`
`49`	`50`	`\| StatementKind::Deinit(_)`
`50`	`51`	`\| StatementKind::Nop => {}`
`51`		`- _ => self.cost += INSTR_COST,`
	`52`	`+ _ => self.penalty += INSTR_COST,`
`52`	`53`	`}`
`53`	`54`	`}`
`54`	`55`
`@@ -59,17 +60,17 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {`
`59`	`60`	`// If the place doesn't actually need dropping, treat it like a regular goto.`
`60`	`61`	`let ty = self.instantiate_ty(place.ty(self.callee_body, tcx).ty);`
`61`	`62`	`if ty.needs_drop(tcx, self.param_env) {`
`62`		`- self.cost += CALL_PENALTY;`
	`63`	`+ self.penalty += CALL_PENALTY;`
`63`	`64`	`if let UnwindAction::Cleanup(_) = unwind {`
`64`		`- self.cost += LANDINGPAD_PENALTY;`
	`65`	`+ self.penalty += LANDINGPAD_PENALTY;`
`65`	`66`	`}`
`66`	`67`	`} else {`
`67`		`- self.cost += INSTR_COST;`
	`68`	`+ self.penalty += INSTR_COST;`
`68`	`69`	`}`
`69`	`70`	`}`
`70`	`71`	`TerminatorKind::Call { func: Operand::Constant(ref f), unwind, .. } => {`
`71`	`72`	`let fn_ty = self.instantiate_ty(f.const_.ty());`
`72`		`- self.cost += if let ty::FnDef(def_id, _) = *fn_ty.kind()`
	`73`	`+ self.penalty += if let ty::FnDef(def_id, _) = *fn_ty.kind()`
`73`	`74`	`&& tcx.intrinsic(def_id).is_some()`
`74`	`75`	`{`
`75`	`76`	`// Don't give intrinsics the extra penalty for calls`
`@@ -78,23 +79,23 @@ impl<'tcx> Visitor<'tcx> for CostChecker<'_, 'tcx> {`
`78`	`79`	`CALL_PENALTY`
`79`	`80`	`};`
`80`	`81`	`if let UnwindAction::Cleanup(_) = unwind {`
`81`		`- self.cost += LANDINGPAD_PENALTY;`
	`82`	`+ self.penalty += LANDINGPAD_PENALTY;`
`82`	`83`	`}`
`83`	`84`	`}`
`84`	`85`	`TerminatorKind::Assert { unwind, .. } => {`
`85`		`- self.cost += CALL_PENALTY;`
	`86`	`+ self.penalty += CALL_PENALTY;`
`86`	`87`	`if let UnwindAction::Cleanup(_) = unwind {`
`87`		`- self.cost += LANDINGPAD_PENALTY;`
	`88`	`+ self.penalty += LANDINGPAD_PENALTY;`
`88`	`89`	`}`
`89`	`90`	`}`
`90`		`- TerminatorKind::UnwindResume => self.cost += RESUME_PENALTY,`
	`91`	`+ TerminatorKind::UnwindResume => self.penalty += RESUME_PENALTY,`
`91`	`92`	`TerminatorKind::InlineAsm { unwind, .. } => {`
`92`		`- self.cost += INSTR_COST;`
	`93`	`+ self.penalty += INSTR_COST;`
`93`	`94`	`if let UnwindAction::Cleanup(_) = unwind {`
`94`		`- self.cost += LANDINGPAD_PENALTY;`
	`95`	`+ self.penalty += LANDINGPAD_PENALTY;`
`95`	`96`	`}`
`96`	`97`	`}`
`97`		`- _ => self.cost += INSTR_COST,`
	`98`	`+ _ => self.penalty += INSTR_COST,`
`98`	`99`	`}`
`99`	`100`	`}`
`100`	`101`	`}`