|
| 1 | +use std::cmp::Reverse; |
| 2 | +use std::collections::BTreeSet; |
| 3 | +use std::fmt::Debug; |
| 4 | +use std::ops::Bound; |
| 5 | + |
| 6 | +use rustc_abi::{ |
| 7 | + BackendRepr, FieldIdx, FieldsShape, Integer, Layout, LayoutData, Primitive, Scalar, Size, |
| 8 | + TagEncoding, TyAndLayout, Variants, WrappingRange, |
| 9 | +}; |
| 10 | +use rustc_index::bit_set::BitSet; |
| 11 | +use rustc_index::{Idx, IndexVec}; |
| 12 | +use rustc_middle::mir::CoroutineSavedLocal; |
| 13 | +use rustc_middle::ty::layout::{HasTyCtxt, IntegerExt, LayoutCx, LayoutError, LayoutOf}; |
| 14 | +use rustc_middle::ty::{EarlyBinder, GenericArgsRef, Ty}; |
| 15 | +use tracing::{debug, instrument}; |
| 16 | + |
| 17 | +use super::error; |
| 18 | + |
| 19 | +#[instrument(level = "debug", skip(cx))] |
| 20 | +pub(super) fn coroutine_layout<'tcx>( |
| 21 | + cx: &LayoutCx<'tcx>, |
| 22 | + ty: Ty<'tcx>, |
| 23 | + def_id: rustc_hir::def_id::DefId, |
| 24 | + args: GenericArgsRef<'tcx>, |
| 25 | +) -> Result<Layout<'tcx>, &'tcx LayoutError<'tcx>> { |
| 26 | + let tcx = cx.tcx(); |
| 27 | + let Some(info) = tcx.coroutine_layout(def_id, args.as_coroutine().kind_ty()) else { |
| 28 | + return Err(error(cx, LayoutError::Unknown(ty))); |
| 29 | + }; |
| 30 | + let mut relocated_upvars = info.relocated_upvars.clone(); |
| 31 | + for (&source, &dest) in &info.relocated_upvars { |
| 32 | + relocated_upvars.insert(dest, source); |
| 33 | + } |
| 34 | + |
| 35 | + let tcx = cx.tcx(); |
| 36 | + let field_layouts: IndexVec<CoroutineSavedLocal, _> = info |
| 37 | + .field_tys |
| 38 | + .iter_enumerated() |
| 39 | + .map(|(saved_local, ty)| { |
| 40 | + let ty = EarlyBinder::bind(ty.ty).instantiate(tcx, args); |
| 41 | + cx.spanned_layout_of(ty, info.field_tys[saved_local].source_info.span) |
| 42 | + }) |
| 43 | + .try_collect()?; |
| 44 | + let layouts: IndexVec<CoroutineSavedLocal, _> = |
| 45 | + field_layouts.iter().map(|data| data.layout.clone()).collect(); |
| 46 | + |
| 47 | + let field_sort_keys: IndexVec<CoroutineSavedLocal, _>; |
| 48 | + let mut saved_locals: Vec<_>; |
| 49 | + // ## The heuristic on which saved locals get allocation first ## |
| 50 | + // 1. the alignment |
| 51 | + // Intuitively data with a larger alignment asks for a larger block of contiguous memory. |
| 52 | + // It is easier to get large blocks early in the beginning, but it will get harder to |
| 53 | + // recover them as fragmentation creeps in when data with smaller alignment occupies |
| 54 | + // the large chunks. |
| 55 | + // 2. the size |
| 56 | + // The size also poses restriction on layout, but not as potent as alignment. |
| 57 | + // 3. the degree of conflicts |
| 58 | + // This metric is the number of confliciting saved locals with a given saved local. |
| 59 | + // Preferring allocating highly conflicting data over those that are less and more |
| 60 | + // transient in nature will keep the fragmentation contained in neighbourhoods of a layout. |
| 61 | + (saved_locals, field_sort_keys) = field_layouts |
| 62 | + .iter_enumerated() |
| 63 | + .map(|(saved_local, ty)| { |
| 64 | + ( |
| 65 | + saved_local, |
| 66 | + ( |
| 67 | + Reverse(ty.align.abi), |
| 68 | + Reverse(ty.size), |
| 69 | + Reverse(info.storage_conflicts.count(saved_local)), |
| 70 | + ), |
| 71 | + ) |
| 72 | + }) |
| 73 | + .unzip(); |
| 74 | + let mut uninhabited_or_zst = BitSet::new_empty(saved_locals.len()); |
| 75 | + for (saved_local, ty) in field_layouts.iter_enumerated() { |
| 76 | + if ty.backend_repr.is_uninhabited() || ty.is_zst() { |
| 77 | + uninhabited_or_zst.insert(saved_local); |
| 78 | + } |
| 79 | + } |
| 80 | + saved_locals.sort_by_key(|&idx| &field_sort_keys[idx]); |
| 81 | + let max_discr = (info.variant_fields.len() - 1) as u128; |
| 82 | + let discr_int = Integer::fit_unsigned(max_discr); |
| 83 | + let tag = Scalar::Initialized { |
| 84 | + value: Primitive::Int(discr_int, false), |
| 85 | + valid_range: WrappingRange { start: 0, end: max_discr }, |
| 86 | + }; |
| 87 | + let tag_layout = TyAndLayout { |
| 88 | + ty: discr_int.to_ty(tcx, false), |
| 89 | + layout: tcx.mk_layout(LayoutData::scalar(cx, tag)), |
| 90 | + }; |
| 91 | + // This will be *the* align of the entire coroutine, |
| 92 | + // which is the maximal alignment of all saved locals. |
| 93 | + // We need to also consider the tag layout alignment. |
| 94 | + let align = saved_locals |
| 95 | + .get(0) |
| 96 | + .map(|&idx| layouts[idx].align.max(tag_layout.align)) |
| 97 | + .unwrap_or(tag_layout.align); |
| 98 | + |
| 99 | + // ## The blocked map, or the reservation map ## |
| 100 | + // This map from saved locals to memory layout records the reservation |
| 101 | + // status of the coroutine state memory, down to the byte granularity. |
| 102 | + // `Slot`s are inserted to mark ranges of memory that a particular saved local |
| 103 | + // shall not have overlapping memory allocation, due to the liveness of |
| 104 | + // other conflicting saved locals. |
| 105 | + // Therefore, we can try to make reservation for this saved local |
| 106 | + // by inspecting the gaps before, between, and after those blocked-out memory ranges. |
| 107 | + let mut blocked: IndexVec<CoroutineSavedLocal, BTreeSet<Slot>> = |
| 108 | + IndexVec::from_elem_n(BTreeSet::new(), saved_locals.len()); |
| 109 | + let mut has_assignment = BitSet::new_empty(saved_locals.len()); |
| 110 | + let mut tag_blocked = BTreeSet::new(); |
| 111 | + let mut assignment = IndexVec::from_elem_n(Slot { start: 0, end: 0 }, saved_locals.len()); |
| 112 | + for (idx, ¤t_local) in saved_locals.iter().enumerate() { |
| 113 | + if uninhabited_or_zst.contains(current_local) { |
| 114 | + // Do not bother to compute on uninhabited data. |
| 115 | + // They will not get allocation after all. |
| 116 | + // By default, a ZST occupies the beginning of the coroutine state. |
| 117 | + continue; |
| 118 | + } |
| 119 | + let layout_data = &field_layouts[current_local]; |
| 120 | + |
| 121 | + let candidate = if let Some(&another_local) = relocated_upvars.get(¤t_local) |
| 122 | + && has_assignment.contains(another_local) |
| 123 | + { |
| 124 | + assignment[another_local] |
| 125 | + } else { |
| 126 | + find_lowest_viable_allocation(&layout_data, &blocked[current_local]) |
| 127 | + }; |
| 128 | + // The discriminant is certainly conflicting with all the saved locals |
| 129 | + merge_slot_in(&mut tag_blocked, candidate); |
| 130 | + for &other_local in &saved_locals[idx + 1..] { |
| 131 | + if info.storage_conflicts.contains(current_local, other_local) { |
| 132 | + merge_slot_in(&mut blocked[other_local], candidate); |
| 133 | + } |
| 134 | + } |
| 135 | + // Adjustment to the layout of this field by shifting them into the chosen slot |
| 136 | + assignment[current_local] = candidate; |
| 137 | + has_assignment.insert(current_local); |
| 138 | + } |
| 139 | + debug!(assignment = ?assignment.debug_map_view()); |
| 140 | + |
| 141 | + // Find a slot for discriminant, also known as the tag. |
| 142 | + let tag_candidate = find_lowest_viable_allocation(&tag_layout, &tag_blocked); |
| 143 | + debug!(tag = ?tag_candidate); |
| 144 | + |
| 145 | + // Assemble the layout for each coroutine state |
| 146 | + let variants: IndexVec<_, LayoutData<_, _>> = info |
| 147 | + .variant_fields |
| 148 | + .iter_enumerated() |
| 149 | + .map(|(index, fields)| { |
| 150 | + let size = Size::from_bytes( |
| 151 | + fields |
| 152 | + .iter() |
| 153 | + .map(|&saved_local| assignment[saved_local].end) |
| 154 | + .max() |
| 155 | + .unwrap_or(0) |
| 156 | + .max(tag_candidate.end), |
| 157 | + ) |
| 158 | + .align_to(align.abi); |
| 159 | + let offsets: IndexVec<_, _> = fields |
| 160 | + .iter() |
| 161 | + .map(|&saved_local| Size::from_bytes(assignment[saved_local].start)) |
| 162 | + .collect(); |
| 163 | + let memory_index = IndexVec::from_fn_n(|n: FieldIdx| (n.index() as u32), offsets.len()); |
| 164 | + LayoutData { |
| 165 | + // We are aware of specialized layouts such as scalar pairs but this is still |
| 166 | + // in development. |
| 167 | + // Let us hold off from further optimisation until more information is available. |
| 168 | + fields: FieldsShape::Arbitrary { offsets, memory_index }, |
| 169 | + variants: Variants::Single { index }, |
| 170 | + backend_repr: BackendRepr::Memory { sized: true }, |
| 171 | + largest_niche: None, |
| 172 | + align, |
| 173 | + size, |
| 174 | + max_repr_align: None, |
| 175 | + unadjusted_abi_align: align.abi, |
| 176 | + } |
| 177 | + }) |
| 178 | + .collect(); |
| 179 | + let size = variants |
| 180 | + .iter() |
| 181 | + .map(|data| data.size) |
| 182 | + .max() |
| 183 | + .unwrap_or(Size::ZERO) |
| 184 | + .max(Size::from_bytes(tag_candidate.end)) |
| 185 | + .align_to(align.abi); |
| 186 | + let layout = tcx.mk_layout(LayoutData { |
| 187 | + fields: FieldsShape::Arbitrary { |
| 188 | + offsets: [Size::from_bytes(tag_candidate.start)].into(), |
| 189 | + memory_index: [0].into(), |
| 190 | + }, |
| 191 | + variants: Variants::Multiple { |
| 192 | + tag, |
| 193 | + tag_encoding: TagEncoding::Direct, |
| 194 | + tag_field: 0, |
| 195 | + variants, |
| 196 | + }, |
| 197 | + backend_repr: BackendRepr::Memory { sized: true }, |
| 198 | + // Suppress niches inside coroutines. If the niche is inside a field that is aliased (due to |
| 199 | + // self-referentiality), getting the discriminant can cause aliasing violations. |
| 200 | + // `UnsafeCell` blocks niches for the same reason, but we don't yet have `UnsafePinned` that |
| 201 | + // would do the same for us here. |
| 202 | + // See <https://github.com/rust-lang/rust/issues/63818>, <https://github.com/rust-lang/miri/issues/3780>. |
| 203 | + // FIXME(#125735): Remove when <https://github.com/rust-lang/rust/issues/125735> |
| 204 | + // is implemented and aliased coroutine fields are wrapped in `UnsafePinned`. |
| 205 | + // NOTE(@dingxiangfei2009): I believe there is still niche, which is the tag, |
| 206 | + // but I am not sure how much benefit is there for us to grab. |
| 207 | + largest_niche: None, |
| 208 | + align, |
| 209 | + size, |
| 210 | + max_repr_align: None, |
| 211 | + unadjusted_abi_align: align.abi, |
| 212 | + }); |
| 213 | + debug!("coroutine layout ({:?}): {:#?}", ty, layout); |
| 214 | + Ok(layout) |
| 215 | +} |
| 216 | + |
| 217 | +/// An occupied slot in the coroutine memory at some yield point |
| 218 | +#[derive(PartialEq, Eq, Copy, Clone)] |
| 219 | +struct Slot { |
| 220 | + /// Beginning of the memory slot, inclusive |
| 221 | + start: u64, |
| 222 | + /// End of the memory slot, exclusive or one byte past the data |
| 223 | + end: u64, |
| 224 | +} |
| 225 | + |
| 226 | +impl PartialOrd for Slot { |
| 227 | + fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> { |
| 228 | + (self.start, self.end).partial_cmp(&(other.start, other.end)) |
| 229 | + } |
| 230 | +} |
| 231 | + |
| 232 | +impl Ord for Slot { |
| 233 | + fn cmp(&self, other: &Self) -> std::cmp::Ordering { |
| 234 | + (self.start, self.end).cmp(&(other.start, other.end)) |
| 235 | + } |
| 236 | +} |
| 237 | + |
| 238 | +impl Debug for Slot { |
| 239 | + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| 240 | + f.debug_tuple("Slot").field(&self.start).field(&self.end).finish() |
| 241 | + } |
| 242 | +} |
| 243 | + |
| 244 | +impl Slot { |
| 245 | + fn overlap_with(&self, other: &Self) -> bool { |
| 246 | + if self.start == self.end || other.start == other.end { |
| 247 | + return false; |
| 248 | + } |
| 249 | + self.contains_point(other.start) || other.contains_point(self.start) |
| 250 | + } |
| 251 | + fn contains_point(&self, point: u64) -> bool { |
| 252 | + self.start <= point && point < self.end |
| 253 | + } |
| 254 | +} |
| 255 | + |
| 256 | +fn merge_slot_in(slots: &mut BTreeSet<Slot>, slot: Slot) { |
| 257 | + let start = Slot { start: slot.start, end: slot.start }; |
| 258 | + let end = Slot { start: slot.end, end: slot.end }; |
| 259 | + let one_past_end = Slot { start: slot.end + 1, end: slot.end + 1 }; |
| 260 | + let (range_start, replace_start) = if let Some(prev) = slots.range(..start).next_back() |
| 261 | + && (prev.end == slot.start || prev.contains_point(slot.start)) |
| 262 | + { |
| 263 | + (Bound::Included(prev), prev.start) |
| 264 | + } else { |
| 265 | + (Bound::Included(&start), slot.start) |
| 266 | + }; |
| 267 | + let (range_end, replace_end) = if let Some(next) = slots.range(..one_past_end).next_back() |
| 268 | + && next.start == slot.end |
| 269 | + { |
| 270 | + (Bound::Included(next), next.end) |
| 271 | + } else if let Some(prev) = slots.range(..end).next_back() |
| 272 | + && prev.contains_point(slot.end) |
| 273 | + { |
| 274 | + (Bound::Included(prev), prev.end) |
| 275 | + } else { |
| 276 | + (Bound::Included(&end), slot.end) |
| 277 | + }; |
| 278 | + let to_remove: Vec<_> = slots.range((range_start, range_end)).copied().collect(); |
| 279 | + for slot in to_remove { |
| 280 | + slots.remove(&slot); |
| 281 | + } |
| 282 | + slots.insert(Slot { start: replace_start, end: replace_end }); |
| 283 | +} |
| 284 | + |
| 285 | +fn find_lowest_viable_allocation<F: Idx, V: Idx>( |
| 286 | + layout: &LayoutData<F, V>, |
| 287 | + blocked: &BTreeSet<Slot>, |
| 288 | +) -> Slot { |
| 289 | + let size = layout.size.bytes(); |
| 290 | + let align = layout.align.abi; |
| 291 | + let mut candidate = Slot { start: 0, end: size }; |
| 292 | + for slot in blocked { |
| 293 | + if slot.overlap_with(&candidate) { |
| 294 | + let start = Size::from_bytes(slot.end).align_to(align).bytes(); |
| 295 | + candidate = Slot { start, end: start + size }; |
| 296 | + } else { |
| 297 | + break; |
| 298 | + } |
| 299 | + } |
| 300 | + candidate |
| 301 | +} |
0 commit comments