10
10
// keys: [K; 2 * B - 1],
11
11
// vals: [V; 2 * B - 1],
12
12
// edges: [if height > 0 { Box<Node<K, V, height - 1>> } else { () }; 2 * B],
13
- // parent: Option<(NonNull<Node<K, V, height + 1>>, u16 )>,
14
- // len: u16 ,
13
+ // parent: Option<(NonNull<Node<K, V, height + 1>>, PackedLength )>,
14
+ // len: PackedLength ,
15
15
// }
16
16
// ```
17
17
//
@@ -47,6 +47,15 @@ const KV_IDX_CENTER: usize = B - 1;
47
47
const EDGE_IDX_LEFT_OF_CENTER : usize = B - 1 ;
48
48
const EDGE_IDX_RIGHT_OF_CENTER : usize = B ;
49
49
50
+ #[ cfg( target_pointer_width = "64" ) ]
51
+ type PackedLength = u32 ;
52
+
53
+ #[ cfg( target_pointer_width = "32" ) ]
54
+ type PackedLength = u16 ;
55
+
56
+ #[ cfg( target_pointer_width = "16" ) ]
57
+ type PackedLength = u8 ;
58
+
50
59
/// The underlying representation of leaf nodes and part of the representation of internal nodes.
51
60
struct LeafNode < K , V > {
52
61
/// We want to be covariant in `K` and `V`.
@@ -55,10 +64,10 @@ struct LeafNode<K, V> {
55
64
/// This node's index into the parent node's `edges` array.
56
65
/// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.
57
66
/// This is only guaranteed to be initialized when `parent` is non-null.
58
- parent_idx : MaybeUninit < u16 > ,
67
+ parent_idx : MaybeUninit < PackedLength > ,
59
68
60
69
/// The number of keys and values this node stores.
61
- len : u16 ,
70
+ len : PackedLength ,
62
71
63
72
/// The arrays storing the actual data of the node. Only the first `len` elements of each
64
73
/// array are initialized and valid.
@@ -341,7 +350,7 @@ impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
341
350
pub fn len ( & self ) -> usize {
342
351
// Crucially, we only access the `len` field here. If BorrowType is marker::ValMut,
343
352
// there might be outstanding mutable references to values that we must not invalidate.
344
- unsafe { usize :: from ( ( * Self :: as_leaf_ptr ( self ) ) . len ) }
353
+ unsafe { ( * Self :: as_leaf_ptr ( self ) ) . len as usize }
345
354
}
346
355
347
356
/// Returns the number of levels that the node and leaves are apart. Zero
@@ -390,7 +399,7 @@ impl<BorrowType: marker::BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type>
390
399
. as_ref ( )
391
400
. map ( |parent| Handle {
392
401
node : NodeRef :: from_internal ( * parent, self . height + 1 ) ,
393
- idx : unsafe { usize :: from ( ( * leaf_ptr) . parent_idx . assume_init ( ) ) } ,
402
+ idx : unsafe { ( * leaf_ptr) . parent_idx . assume_init ( ) as usize } ,
394
403
_marker : PhantomData ,
395
404
} )
396
405
. ok_or ( self )
@@ -431,9 +440,8 @@ impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Immut<'a>, K, V, Type> {
431
440
/// Borrows a view into the keys stored in the node.
432
441
pub fn keys ( & self ) -> & [ K ] {
433
442
let leaf = self . into_leaf ( ) ;
434
- unsafe {
435
- MaybeUninit :: slice_assume_init_ref ( leaf. keys . get_unchecked ( ..usize:: from ( leaf. len ) ) )
436
- }
443
+ let len = leaf. len as usize ;
444
+ unsafe { MaybeUninit :: slice_assume_init_ref ( leaf. keys . get_unchecked ( ..len) ) }
437
445
}
438
446
}
439
447
@@ -570,7 +578,7 @@ impl<'a, K, V, Type> NodeRef<marker::ValMut<'a>, K, V, Type> {
570
578
571
579
impl < ' a , K : ' a , V : ' a , Type > NodeRef < marker:: Mut < ' a > , K , V , Type > {
572
580
/// Borrows exclusive access to the length of the node.
573
- pub fn len_mut ( & mut self ) -> & mut u16 {
581
+ pub fn len_mut ( & mut self ) -> & mut PackedLength {
574
582
& mut self . as_leaf_mut ( ) . len
575
583
}
576
584
}
@@ -581,7 +589,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
581
589
fn set_parent_link ( & mut self , parent : NonNull < InternalNode < K , V > > , parent_idx : usize ) {
582
590
let leaf = Self :: as_leaf_ptr ( self ) ;
583
591
unsafe { ( * leaf) . parent = Some ( parent) } ;
584
- unsafe { ( * leaf) . parent_idx . write ( parent_idx as u16 ) } ;
592
+ unsafe { ( * leaf) . parent_idx . write ( parent_idx as PackedLength ) } ;
585
593
}
586
594
}
587
595
@@ -598,7 +606,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::Leaf> {
598
606
/// Adds a key-value pair to the end of the node.
599
607
pub fn push ( & mut self , key : K , val : V ) {
600
608
let len = self . len_mut ( ) ;
601
- let idx = usize :: from ( * len) ;
609
+ let idx = * len as usize ;
602
610
assert ! ( idx < CAPACITY ) ;
603
611
* len += 1 ;
604
612
unsafe {
@@ -631,7 +639,7 @@ impl<'a, K: 'a, V: 'a> NodeRef<marker::Mut<'a>, K, V, marker::Internal> {
631
639
assert ! ( edge. height == self . height - 1 ) ;
632
640
633
641
let len = self . len_mut ( ) ;
634
- let idx = usize :: from ( * len) ;
642
+ let idx = * len as usize ;
635
643
assert ! ( idx < CAPACITY ) ;
636
644
* len += 1 ;
637
645
unsafe {
@@ -843,7 +851,7 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, mark
843
851
unsafe {
844
852
slice_insert ( self . node . key_area_mut ( ..new_len) , self . idx , key) ;
845
853
slice_insert ( self . node . val_area_mut ( ..new_len) , self . idx , val) ;
846
- * self . node . len_mut ( ) = new_len as u16 ;
854
+ * self . node . len_mut ( ) = new_len as PackedLength ;
847
855
848
856
self . node . val_area_mut ( self . idx ) . assume_init_mut ( )
849
857
}
@@ -903,7 +911,7 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>,
903
911
slice_insert ( self . node . key_area_mut ( ..new_len) , self . idx , key) ;
904
912
slice_insert ( self . node . val_area_mut ( ..new_len) , self . idx , val) ;
905
913
slice_insert ( self . node . edge_area_mut ( ..new_len + 1 ) , self . idx + 1 , edge. node ) ;
906
- * self . node . len_mut ( ) = new_len as u16 ;
914
+ * self . node . len_mut ( ) = new_len as PackedLength ;
907
915
908
916
self . node . correct_childrens_parent_links ( self . idx + 1 ..new_len + 1 ) ;
909
917
}
@@ -1057,7 +1065,7 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>
1057
1065
debug_assert ! ( self . idx < self . node. len( ) ) ;
1058
1066
let old_len = self . node . len ( ) ;
1059
1067
let new_len = old_len - self . idx - 1 ;
1060
- new_node. len = new_len as u16 ;
1068
+ new_node. len = new_len as PackedLength ;
1061
1069
unsafe {
1062
1070
let k = self . node . key_area_mut ( self . idx ) . assume_init_read ( ) ;
1063
1071
let v = self . node . val_area_mut ( self . idx ) . assume_init_read ( ) ;
@@ -1071,7 +1079,7 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>
1071
1079
& mut new_node. vals [ ..new_len] ,
1072
1080
) ;
1073
1081
1074
- * self . node . len_mut ( ) = self . idx as u16 ;
1082
+ * self . node . len_mut ( ) = self . idx as PackedLength ;
1075
1083
( k, v)
1076
1084
}
1077
1085
}
@@ -1105,7 +1113,7 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, mark
1105
1113
unsafe {
1106
1114
let k = slice_remove ( self . node . key_area_mut ( ..old_len) , self . idx ) ;
1107
1115
let v = slice_remove ( self . node . val_area_mut ( ..old_len) , self . idx ) ;
1108
- * self . node . len_mut ( ) = ( old_len - 1 ) as u16 ;
1116
+ * self . node . len_mut ( ) = ( old_len - 1 ) as PackedLength ;
1109
1117
( ( k, v) , self . left_edge ( ) )
1110
1118
}
1111
1119
}
@@ -1124,7 +1132,7 @@ impl<'a, K: 'a, V: 'a> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>,
1124
1132
unsafe {
1125
1133
let mut new_node = InternalNode :: new ( ) ;
1126
1134
let kv = self . split_leaf_data ( & mut new_node. data ) ;
1127
- let new_len = usize :: from ( new_node. data . len ) ;
1135
+ let new_len = new_node. data . len as usize ;
1128
1136
move_to_slice (
1129
1137
self . node . edge_area_mut ( self . idx + 1 ..old_len + 1 ) ,
1130
1138
& mut new_node. edges [ ..new_len + 1 ] ,
@@ -1242,7 +1250,7 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> {
1242
1250
assert ! ( new_left_len <= CAPACITY ) ;
1243
1251
1244
1252
unsafe {
1245
- * left_node. len_mut ( ) = new_left_len as u16 ;
1253
+ * left_node. len_mut ( ) = new_left_len as PackedLength ;
1246
1254
1247
1255
let parent_key = slice_remove ( parent_node. key_area_mut ( ..old_parent_len) , parent_idx) ;
1248
1256
left_node. key_area_mut ( old_left_len) . write ( parent_key) ;
@@ -1360,8 +1368,8 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> {
1360
1368
1361
1369
let new_left_len = old_left_len - count;
1362
1370
let new_right_len = old_right_len + count;
1363
- * left_node. len_mut ( ) = new_left_len as u16 ;
1364
- * right_node. len_mut ( ) = new_right_len as u16 ;
1371
+ * left_node. len_mut ( ) = new_left_len as PackedLength ;
1372
+ * right_node. len_mut ( ) = new_right_len as PackedLength ;
1365
1373
1366
1374
// Move leaf data.
1367
1375
{
@@ -1423,8 +1431,8 @@ impl<'a, K: 'a, V: 'a> BalancingContext<'a, K, V> {
1423
1431
1424
1432
let new_left_len = old_left_len + count;
1425
1433
let new_right_len = old_right_len - count;
1426
- * left_node. len_mut ( ) = new_left_len as u16 ;
1427
- * right_node. len_mut ( ) = new_right_len as u16 ;
1434
+ * left_node. len_mut ( ) = new_left_len as PackedLength ;
1435
+ * right_node. len_mut ( ) = new_right_len as PackedLength ;
1428
1436
1429
1437
// Move leaf data.
1430
1438
{
@@ -1559,8 +1567,8 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, ma
1559
1567
assert ! ( left_node. height == right_node. height) ;
1560
1568
1561
1569
if new_right_len > 0 {
1562
- * left_node. len_mut ( ) = new_left_len as u16 ;
1563
- * right_node. len_mut ( ) = new_right_len as u16 ;
1570
+ * left_node. len_mut ( ) = new_left_len as PackedLength ;
1571
+ * right_node. len_mut ( ) = new_right_len as PackedLength ;
1564
1572
1565
1573
move_to_slice (
1566
1574
left_node. key_area_mut ( new_left_len..old_left_len) ,
0 commit comments