@@ -44,29 +44,35 @@ impl Chunk {
4444 }
4545}
4646
47- /// Chunk allocation state
47+ /// The allocation state for a chunk in the chunk map. It includes whether each chunk is allocated or free, and the space the chunk belongs to.
4848/// Highest bit: 0 = free, 1 = allocated
4949/// Lower 4 bits: Space index (0-15)
5050#[ repr( transparent) ]
5151#[ derive( PartialEq , Clone , Copy ) ]
5252pub struct ChunkState ( u8 ) ;
5353
5454impl ChunkState {
55+ /// Create a new ChunkState that represents being allocated in the given space
5556pub fn allocated ( space_index : usize ) -> ChunkState {
5657 debug_assert ! ( space_index < crate :: util:: heap:: layout:: heap_parameters:: MAX_SPACES ) ;
5758 let mut encode = space_index as u8 ;
5859 encode |= 0x80 ;
5960 ChunkState ( encode)
6061 }
61- pub fn free ( ) -> ChunkState {
62- ChunkState ( 0 )
62+ /// Create a new ChunkState that represents being free in the given space
63+ pub fn free ( space_index : usize ) -> ChunkState {
64+ debug_assert ! ( space_index < crate :: util:: heap:: layout:: heap_parameters:: MAX_SPACES ) ;
65+ ChunkState ( space_index as u8 )
6366 }
67+ /// Is the chunk free?
6468pub fn is_free ( & self ) -> bool {
6569 self . 0 & 0x80 == 0
6670 }
71+ /// Is the chunk allocated?
6772pub fn is_allocated ( & self ) -> bool {
6873 !self . is_free ( )
6974 }
75+ /// Get the space index of the chunk
7076pub fn get_space_index ( & self ) -> usize {
7177 debug_assert ! ( self . is_allocated( ) ) ;
7278 let index = ( self . 0 & 0x0F ) as usize ;
@@ -78,17 +84,26 @@ impl ChunkState {
7884impl std:: fmt:: Debug for ChunkState {
7985 fn fmt ( & self , f : & mut std:: fmt:: Formatter < ' _ > ) -> std:: fmt:: Result {
8086 if self . is_free ( ) {
81- write ! ( f, "Free" )
87+ write ! ( f, "Free({})" , self . get_space_index ( ) )
8288 } else {
83- write ! ( f, "Allocated in space {} " , self . get_space_index( ) )
89+ write ! ( f, "Allocated({}) " , self . get_space_index( ) )
8490 }
8591 }
8692}
8793
8894/// A byte-map to record all the allocated chunks.
8995/// A plan can use this to maintain records for the chunks that they used, and the states of the chunks.
90- /// Any plan that uses the chunk map should include the `ALLOC_TABLE` spec in their local sidemetadata specs
96+ /// Any plan that uses the chunk map should include the `ALLOC_TABLE` spec in their local sidemetadata specs.
97+ ///
98+ /// A chunk map is created for a space (identified by the space index), and will only update or list chunks for that space.
9199pub struct ChunkMap {
100+ /// The space that uses this chunk map.
101+ space_index : usize ,
102+ /// The range of chunks that are used by the space. The range only records the lowest chunk and the highest chunk.
103+ /// All the chunks that are used for the space are within the range, but not necessarily that all the chunks in the range
104+ /// are used for the space. Spaces may be discontiguous, thus the range may include chunks that do not belong to the space.
105+ /// We need to use the space index in the chunk map and the space index encoded with the chunk state to know if
106+ /// the chunk belongs to the current space.
92107chunk_range : Mutex < Range < Chunk > > ,
93108}
94109
@@ -97,24 +112,35 @@ impl ChunkMap {
97112pub const ALLOC_TABLE : SideMetadataSpec =
98113 crate :: util:: metadata:: side_metadata:: spec_defs:: CHUNK_MARK ;
99114
100- pub fn new ( ) -> Self {
115+ pub fn new ( space_index : usize ) -> Self {
101116 Self {
117+ space_index,
102118 chunk_range : Mutex :: new ( Chunk :: ZERO ..Chunk :: ZERO ) ,
103119 }
104120 }
105121
106- /// Set chunk state
107- pub fn set ( & self , chunk : Chunk , state : ChunkState ) {
122+ /// Set a chunk as allocated, or as free.
123+ pub fn set_allocated ( & self , chunk : Chunk , allocated : bool ) {
124+ let state = if allocated {
125+ ChunkState :: allocated ( self . space_index )
126+ } else {
127+ ChunkState :: free ( self . space_index )
128+ } ;
108129 // Do nothing if the chunk is already in the expected state.
109- if self . get ( chunk) == state {
130+ if self . get_any ( chunk) == state {
110131 return ;
111132 }
112133 #[ cfg( debug_assertions) ]
113134 {
114- let old_state = self . get ( chunk) ;
115- if state. is_allocated ( ) {
116- assert ! ( old_state. is_free( ) || old_state. get_space_index( ) == state. get_space_index( ) , "Chunk {:?}: old state {:?}, new state {:?}. Cannot set to new state." , chunk, old_state, state) ;
117- }
135+ let old_state = self . get_any ( chunk) ;
136+ // If a chunk is free, any space may use it. If a chunk is not free, only the current space may update its state.
137+ assert ! (
138+ old_state. is_free( ) || old_state. get_space_index( ) == state. get_space_index( ) ,
139+ "Chunk {:?}: old state {:?}, new state {:?}. Cannot set to new state." ,
140+ chunk,
141+ old_state,
142+ state
143+ ) ;
118144 }
119145 // Update alloc byte
120146 unsafe { Self :: ALLOC_TABLE . store :: < u8 > ( chunk. start ( ) , state. 0 ) } ;
@@ -134,16 +160,30 @@ impl ChunkMap {
134160 }
135161 }
136162
137- /// Get chunk state
138- pub fn get ( & self , chunk : Chunk ) -> ChunkState {
163+ /// Get chunk state. Return None if the chunk does not belong to the space.
164+ pub fn get ( & self , chunk : Chunk ) -> Option < ChunkState > {
165+ let state = self . get_any ( chunk) ;
166+ ( state. get_space_index ( ) == self . space_index ) . then_some ( state)
167+ }
168+
169+ /// Get chunk state, regardless of the space. This should always be private.
170+ fn get_any ( & self , chunk : Chunk ) -> ChunkState {
139171 let byte = unsafe { Self :: ALLOC_TABLE . load :: < u8 > ( chunk. start ( ) ) } ;
140172 ChunkState ( byte)
141173 }
142174
143175 /// A range of all chunks in the heap.
144- pub fn all_chunks ( & self ) -> RegionIterator < Chunk > {
176+ pub fn all_chunks ( & self ) -> impl Iterator < Item = Chunk > + use < ' _ > {
177+ let chunk_range = self . chunk_range . lock ( ) ;
178+ RegionIterator :: < Chunk > :: new ( chunk_range. start , chunk_range. end )
179+ . filter ( |c| self . get ( * c) . is_some ( ) )
180+ }
181+
182+ /// A range of all chunks in the heap.
183+ pub fn all_allocated_chunks ( & self ) -> impl Iterator < Item = Chunk > + use < ' _ > {
145184 let chunk_range = self . chunk_range . lock ( ) ;
146185 RegionIterator :: < Chunk > :: new ( chunk_range. start , chunk_range. end )
186+ . filter ( |c| self . get ( * c) . is_some_and ( |state| state. is_allocated ( ) ) )
147187 }
148188
149189 /// Helper function to create per-chunk processing work packets for each allocated chunks.
@@ -152,18 +192,9 @@ impl ChunkMap {
152192 func : impl Fn ( Chunk ) -> Box < dyn GCWork < VM > > ,
153193 ) -> Vec < Box < dyn GCWork < VM > > > {
154194 let mut work_packets: Vec < Box < dyn GCWork < VM > > > = vec ! [ ] ;
155- for chunk in self
156- . all_chunks ( )
157- . filter ( |c| self . get ( * c) . is_allocated ( ) )
158- {
195+ for chunk in self . all_allocated_chunks ( ) {
159196 work_packets. push ( func ( chunk) ) ;
160197 }
161198 work_packets
162199 }
163200}
164-
165- impl Default for ChunkMap {
166- fn default ( ) -> Self {
167- Self :: new ( )
168- }
169- }
0 commit comments