Skip to content

Commit 663d2f5

Browse files
borsbors
committed
Auto merge of rust-lang#75171 - amosonn:new_zeroed_slice, r=Amanieu
New zeroed slice Add to rust-lang#63291 the methods ```rust impl<T> Box<[T]> { pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>]> {…} } impl<T> Rc<[T]> { pub fn new_zeroed_slice(len: usize) -> Rc<[MaybeUninit<T>]> {…} } impl<T> Arc<[T]> { pub fn new_zeroed_slice(len: usize) -> Arc<[MaybeUninit<T>]> {…} } ``` as suggested in rust-lang#63291 (comment) . Also optimize `{Rc, Arc}::new_zeroed` to use `alloc_zeroed`, otherwise they are no more efficient than using `new_uninit` and zeroing the memory manually (which was the original implementation).
2 parents 5528caf + 5aba816 commit 663d2f5

File tree

3 files changed

+139
-30
lines changed

3 files changed

+139
-30
lines changed

‎library/alloc/src/boxed.rs

+23
Original file line numberDiff line numberDiff line change
@@ -271,6 +271,29 @@ impl<T> Box<[T]> {
271271
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
272272
unsafe { RawVec::with_capacity(len).into_box(len) }
273273
}
274+
275+
/// Constructs a new boxed slice with uninitialized contents, with the memory
276+
/// being filled with `0` bytes.
277+
///
278+
/// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and incorrect usage
279+
/// of this method.
280+
///
281+
/// # Examples
282+
///
283+
/// ```
284+
/// #![feature(new_uninit)]
285+
///
286+
/// let values = Box::<[u32]>::new_zeroed_slice(3);
287+
/// let values = unsafe { values.assume_init() };
288+
///
289+
/// assert_eq!(*values, [0, 0, 0])
290+
/// ```
291+
///
292+
/// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
293+
#[unstable(feature = "new_uninit", issue = "63291")]
294+
pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
295+
unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
296+
}
274297
}
275298

276299
impl<T> Box<mem::MaybeUninit<T>> {

‎library/alloc/src/rc.rs

+58-15
Original file line numberDiff line numberDiff line change
@@ -247,7 +247,7 @@ use core::pin::Pin;
247247
use core::ptr::{self, NonNull};
248248
use core::slice::from_raw_parts_mut;
249249

250-
use crate::alloc::{box_free, handle_alloc_error, AllocRef, Global, Layout};
250+
use crate::alloc::{box_free, handle_alloc_error, AllocErr, AllocRef, Global, Layout};
251251
use crate::borrow::{Cow, ToOwned};
252252
use crate::string::String;
253253
use crate::vec::Vec;
@@ -349,9 +349,11 @@ impl<T> Rc<T> {
349349
#[unstable(feature = "new_uninit", issue = "63291")]
350350
pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
351351
unsafe {
352-
Rc::from_ptr(Rc::allocate_for_layout(Layout::new::<T>(), |mem| {
353-
mem as *mut RcBox<mem::MaybeUninit<T>>
354-
}))
352+
Rc::from_ptr(Rc::allocate_for_layout(
353+
Layout::new::<T>(),
354+
|layout| Global.alloc(layout),
355+
|mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
356+
))
355357
}
356358
}
357359

@@ -378,9 +380,11 @@ impl<T> Rc<T> {
378380
#[unstable(feature = "new_uninit", issue = "63291")]
379381
pub fn new_zeroed() -> Rc<mem::MaybeUninit<T>> {
380382
unsafe {
381-
let mut uninit = Self::new_uninit();
382-
ptr::write_bytes::<T>(Rc::get_mut_unchecked(&mut uninit).as_mut_ptr(), 0, 1);
383-
uninit
383+
Rc::from_ptr(Rc::allocate_for_layout(
384+
Layout::new::<T>(),
385+
|layout| Global.alloc_zeroed(layout),
386+
|mem| mem as *mut RcBox<mem::MaybeUninit<T>>,
387+
))
384388
}
385389
}
386390

@@ -460,6 +464,40 @@ impl<T> Rc<[T]> {
460464
pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
461465
unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
462466
}
467+
468+
/// Constructs a new reference-counted slice with uninitialized contents, with the memory being
469+
/// filled with `0` bytes.
470+
///
471+
/// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and
472+
/// incorrect usage of this method.
473+
///
474+
/// # Examples
475+
///
476+
/// ```
477+
/// #![feature(new_uninit)]
478+
///
479+
/// use std::rc::Rc;
480+
///
481+
/// let values = Rc::<[u32]>::new_zeroed_slice(3);
482+
/// let values = unsafe { values.assume_init() };
483+
///
484+
/// assert_eq!(*values, [0, 0, 0])
485+
/// ```
486+
///
487+
/// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
488+
#[unstable(feature = "new_uninit", issue = "63291")]
489+
pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
490+
unsafe {
491+
Rc::from_ptr(Rc::allocate_for_layout(
492+
Layout::array::<T>(len).unwrap(),
493+
|layout| Global.alloc_zeroed(layout),
494+
|mem| {
495+
ptr::slice_from_raw_parts_mut(mem as *mut T, len)
496+
as *mut RcBox<[mem::MaybeUninit<T>]>
497+
},
498+
))
499+
}
500+
}
463501
}
464502

465503
impl<T> Rc<mem::MaybeUninit<T>> {
@@ -905,6 +943,7 @@ impl<T: ?Sized> Rc<T> {
905943
/// and must return back a (potentially fat)-pointer for the `RcBox<T>`.
906944
unsafe fn allocate_for_layout(
907945
value_layout: Layout,
946+
allocate: impl FnOnce(Layout) -> Result<NonNull<[u8]>, AllocErr>,
908947
mem_to_rcbox: impl FnOnce(*mut u8) -> *mut RcBox<T>,
909948
) -> *mut RcBox<T> {
910949
// Calculate layout using the given value layout.
@@ -914,7 +953,7 @@ impl<T: ?Sized> Rc<T> {
914953
let layout = Layout::new::<RcBox<()>>().extend(value_layout).unwrap().0.pad_to_align();
915954

916955
// Allocate for the layout.
917-
let ptr = Global.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout));
956+
let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout));
918957

919958
// Initialize the RcBox
920959
let inner = mem_to_rcbox(ptr.as_non_null_ptr().as_ptr());
@@ -932,9 +971,11 @@ impl<T: ?Sized> Rc<T> {
932971
unsafe fn allocate_for_ptr(ptr: *const T) -> *mut RcBox<T> {
933972
// Allocate for the `RcBox<T>` using the given value.
934973
unsafe {
935-
Self::allocate_for_layout(Layout::for_value(&*ptr), |mem| {
936-
set_data_ptr(ptr as *mut T, mem) as *mut RcBox<T>
937-
})
974+
Self::allocate_for_layout(
975+
Layout::for_value(&*ptr),
976+
|layout| Global.alloc(layout),
977+
|mem| set_data_ptr(ptr as *mut T, mem) as *mut RcBox<T>,
978+
)
938979
}
939980
}
940981

@@ -965,9 +1006,11 @@ impl<T> Rc<[T]> {
9651006
/// Allocates an `RcBox<[T]>` with the given length.
9661007
unsafe fn allocate_for_slice(len: usize) -> *mut RcBox<[T]> {
9671008
unsafe {
968-
Self::allocate_for_layout(Layout::array::<T>(len).unwrap(), |mem| {
969-
ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>
970-
})
1009+
Self::allocate_for_layout(
1010+
Layout::array::<T>(len).unwrap(),
1011+
|layout| Global.alloc(layout),
1012+
|mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut RcBox<[T]>,
1013+
)
9711014
}
9721015
}
9731016
}
@@ -2061,7 +2104,7 @@ impl<T: ?Sized> AsRef<T> for Rc<T> {
20612104
#[stable(feature = "pin", since = "1.33.0")]
20622105
impl<T: ?Sized> Unpin for Rc<T> {}
20632106

2064-
/// Get the offset within an `ArcInner` for
2107+
/// Get the offset within an `RcBox` for
20652108
/// a payload of type described by a pointer.
20662109
///
20672110
/// # Safety

‎library/alloc/src/sync.rs

+58-15
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,7 @@ use core::slice::from_raw_parts_mut;
2121
use core::sync::atomic;
2222
use core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst};
2323

24-
use crate::alloc::{box_free, handle_alloc_error, AllocRef, Global, Layout};
24+
use crate::alloc::{box_free, handle_alloc_error, AllocErr, AllocRef, Global, Layout};
2525
use crate::borrow::{Cow, ToOwned};
2626
use crate::boxed::Box;
2727
use crate::rc::is_dangling;
@@ -343,9 +343,11 @@ impl<T> Arc<T> {
343343
#[unstable(feature = "new_uninit", issue = "63291")]
344344
pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
345345
unsafe {
346-
Arc::from_ptr(Arc::allocate_for_layout(Layout::new::<T>(), |mem| {
347-
mem as *mut ArcInner<mem::MaybeUninit<T>>
348-
}))
346+
Arc::from_ptr(Arc::allocate_for_layout(
347+
Layout::new::<T>(),
348+
|layout| Global.alloc(layout),
349+
|mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
350+
))
349351
}
350352
}
351353

@@ -372,9 +374,11 @@ impl<T> Arc<T> {
372374
#[unstable(feature = "new_uninit", issue = "63291")]
373375
pub fn new_zeroed() -> Arc<mem::MaybeUninit<T>> {
374376
unsafe {
375-
let mut uninit = Self::new_uninit();
376-
ptr::write_bytes::<T>(Arc::get_mut_unchecked(&mut uninit).as_mut_ptr(), 0, 1);
377-
uninit
377+
Arc::from_ptr(Arc::allocate_for_layout(
378+
Layout::new::<T>(),
379+
|layout| Global.alloc_zeroed(layout),
380+
|mem| mem as *mut ArcInner<mem::MaybeUninit<T>>,
381+
))
378382
}
379383
}
380384

@@ -426,7 +430,7 @@ impl<T> Arc<T> {
426430
}
427431

428432
impl<T> Arc<[T]> {
429-
/// Constructs a new reference-counted slice with uninitialized contents.
433+
/// Constructs a new atomically reference-counted slice with uninitialized contents.
430434
///
431435
/// # Examples
432436
///
@@ -453,6 +457,40 @@ impl<T> Arc<[T]> {
453457
pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
454458
unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
455459
}
460+
461+
/// Constructs a new atomically reference-counted slice with uninitialized contents, with the memory being
462+
/// filled with `0` bytes.
463+
///
464+
/// See [`MaybeUninit::zeroed`][zeroed] for examples of correct and
465+
/// incorrect usage of this method.
466+
///
467+
/// # Examples
468+
///
469+
/// ```
470+
/// #![feature(new_uninit)]
471+
///
472+
/// use std::sync::Arc;
473+
///
474+
/// let values = Arc::<[u32]>::new_zeroed_slice(3);
475+
/// let values = unsafe { values.assume_init() };
476+
///
477+
/// assert_eq!(*values, [0, 0, 0])
478+
/// ```
479+
///
480+
/// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
481+
#[unstable(feature = "new_uninit", issue = "63291")]
482+
pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
483+
unsafe {
484+
Arc::from_ptr(Arc::allocate_for_layout(
485+
Layout::array::<T>(len).unwrap(),
486+
|layout| Global.alloc_zeroed(layout),
487+
|mem| {
488+
ptr::slice_from_raw_parts_mut(mem as *mut T, len)
489+
as *mut ArcInner<[mem::MaybeUninit<T>]>
490+
},
491+
))
492+
}
493+
}
456494
}
457495

458496
impl<T> Arc<mem::MaybeUninit<T>> {
@@ -858,6 +896,7 @@ impl<T: ?Sized> Arc<T> {
858896
/// and must return back a (potentially fat)-pointer for the `ArcInner<T>`.
859897
unsafe fn allocate_for_layout(
860898
value_layout: Layout,
899+
allocate: impl FnOnce(Layout) -> Result<NonNull<[u8]>, AllocErr>,
861900
mem_to_arcinner: impl FnOnce(*mut u8) -> *mut ArcInner<T>,
862901
) -> *mut ArcInner<T> {
863902
// Calculate layout using the given value layout.
@@ -866,7 +905,7 @@ impl<T: ?Sized> Arc<T> {
866905
// reference (see #54908).
867906
let layout = Layout::new::<ArcInner<()>>().extend(value_layout).unwrap().0.pad_to_align();
868907

869-
let ptr = Global.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout));
908+
let ptr = allocate(layout).unwrap_or_else(|_| handle_alloc_error(layout));
870909

871910
// Initialize the ArcInner
872911
let inner = mem_to_arcinner(ptr.as_non_null_ptr().as_ptr());
@@ -884,9 +923,11 @@ impl<T: ?Sized> Arc<T> {
884923
unsafe fn allocate_for_ptr(ptr: *const T) -> *mut ArcInner<T> {
885924
// Allocate for the `ArcInner<T>` using the given value.
886925
unsafe {
887-
Self::allocate_for_layout(Layout::for_value(&*ptr), |mem| {
888-
set_data_ptr(ptr as *mut T, mem) as *mut ArcInner<T>
889-
})
926+
Self::allocate_for_layout(
927+
Layout::for_value(&*ptr),
928+
|layout| Global.alloc(layout),
929+
|mem| set_data_ptr(ptr as *mut T, mem) as *mut ArcInner<T>,
930+
)
890931
}
891932
}
892933

@@ -917,9 +958,11 @@ impl<T> Arc<[T]> {
917958
/// Allocates an `ArcInner<[T]>` with the given length.
918959
unsafe fn allocate_for_slice(len: usize) -> *mut ArcInner<[T]> {
919960
unsafe {
920-
Self::allocate_for_layout(Layout::array::<T>(len).unwrap(), |mem| {
921-
ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>
922-
})
961+
Self::allocate_for_layout(
962+
Layout::array::<T>(len).unwrap(),
963+
|layout| Global.alloc(layout),
964+
|mem| ptr::slice_from_raw_parts_mut(mem as *mut T, len) as *mut ArcInner<[T]>,
965+
)
923966
}
924967
}
925968
}

0 commit comments

Comments
 (0)