Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
d3d2a279
R
Rust
项目概览
int
/
Rust
11 个月 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
d3d2a279
编写于
2月 25, 2022
作者:
J
Josh Stone
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Add Atomic*::from_mut_slice
上级
d981633e
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
94 addition
and
0 deletion
+94
-0
library/core/src/sync/atomic.rs
library/core/src/sync/atomic.rs
+94
-0
未找到文件。
library/core/src/sync/atomic.rs
浏览文件 @
d3d2a279
...
...
@@ -340,6 +340,32 @@ pub fn from_mut(v: &mut bool) -> &mut Self {
unsafe
{
&
mut
*
(
v
as
*
mut
bool
as
*
mut
Self
)
}
}
/// Get atomic access to a `&mut [bool]` slice.
///
/// # Examples
///
/// ```
/// #![feature(atomic_from_mut, scoped_threads)]
/// use std::sync::atomic::{AtomicBool, Ordering};
///
/// let mut some_bools = [false; 10];
/// let a = &*AtomicBool::from_mut_slice(&mut some_bools);
/// std::thread::scope(|s| {
/// for i in 0..a.len() {
/// s.spawn(move |_| a[i].store(true, Ordering::Relaxed));
/// }
/// });
/// assert_eq!(some_bools, [true; 10]);
/// ```
#[inline]
#[cfg(target_has_atomic_equal_alignment
=
"8"
)]
#[unstable(feature
=
"atomic_from_mut"
,
issue
=
"76314"
)]
pub
fn
from_mut_slice
(
v
:
&
mut
[
bool
])
->
&
mut
[
Self
]
{
// SAFETY: the mutable reference guarantees unique ownership, and
// alignment of both `bool` and `Self` is 1.
unsafe
{
&
mut
*
(
v
as
*
mut
[
bool
]
as
*
mut
[
Self
])
}
}
/// Consumes the atomic and returns the contained value.
///
/// This is safe because passing `self` by value guarantees that no other threads are
...
...
@@ -945,6 +971,42 @@ pub fn from_mut(v: &mut *mut T) -> &mut Self {
unsafe
{
&
mut
*
(
v
as
*
mut
*
mut
T
as
*
mut
Self
)
}
}
/// Get atomic access to a slice of pointers.
///
/// # Examples
///
/// ```
/// #![feature(atomic_from_mut, scoped_threads)]
/// use std::ptr::null_mut;
/// use std::sync::atomic::{AtomicPtr, Ordering};
///
/// let mut some_ptrs = [null_mut::<String>(); 10];
/// let a = &*AtomicPtr::from_mut_slice(&mut some_ptrs);
/// std::thread::scope(|s| {
/// for i in 0..a.len() {
/// s.spawn(move |_| {
/// let name = Box::new(format!("thread{i}"));
/// a[i].store(Box::into_raw(name), Ordering::Relaxed);
/// });
/// }
/// });
/// for p in some_ptrs {
/// assert!(!p.is_null());
/// let name = unsafe { Box::from_raw(p) };
/// println!("Hello, {name}!");
/// }
/// ```
#[inline]
#[cfg(target_has_atomic_equal_alignment
=
"ptr"
)]
#[unstable(feature
=
"atomic_from_mut"
,
issue
=
"76314"
)]
pub
fn
from_mut_slice
(
v
:
&
mut
[
*
mut
T
])
->
&
mut
[
Self
]
{
// SAFETY:
// - the mutable reference guarantees unique ownership.
// - the alignment of `*mut T` and `Self` is the same on all platforms
// supported by rust, as verified above.
unsafe
{
&
mut
*
(
v
as
*
mut
[
*
mut
T
]
as
*
mut
[
Self
])
}
}
/// Consumes the atomic and returns the contained value.
///
/// This is safe because passing `self` by value guarantees that no other threads are
...
...
@@ -1459,6 +1521,38 @@ pub fn from_mut(v: &mut $int_type) -> &mut Self {
unsafe
{
&
mut
*
(
v
as
*
mut
$int_type
as
*
mut
Self
)
}
}
#[doc
=
concat
!
(
"Get atomic access to a `&mut ["
,
stringify
!
(
$
int_type),
"]` slice."
)]
///
/// # Examples
///
/// ```
/// #![feature(atomic_from_mut, scoped_threads)]
#[doc
=
concat
!
(
$
extra_feature,
"use std::sync::atomic::{"
,
stringify
!
(
$
atomic_type),
", Ordering};"
)]
///
/// let mut some_ints = [0; 10];
#[doc
=
concat
!
(
"let a = &*"
,
stringify
!
(
$
atomic_type),
"::from_mut_slice(&mut some_ints);"
)]
/// std::thread::scope(|s| {
/// for i in 0..a.len() {
/// s.spawn(move |_| a[i].store(i as _, Ordering::Relaxed));
/// }
/// });
/// for (i, n) in some_ints.into_iter().enumerate() {
/// assert_eq!(i, n as usize);
/// }
/// ```
#[inline]
#[
$
cfg_align]
#[unstable(feature
=
"atomic_from_mut"
,
issue
=
"76314"
)]
pub
fn
from_mut_slice
(
v
:
&
mut
[
$int_type
])
->
&
mut
[
Self
]
{
use
crate
::
mem
::
align_of
;
let
[]
=
[();
align_of
::
<
Self
>
()
-
align_of
::
<
$int_type
>
()];
// SAFETY:
// - the mutable reference guarantees unique ownership.
// - the alignment of `$int_type` and `Self` is the
// same, as promised by $cfg_align and verified above.
unsafe
{
&
mut
*
(
v
as
*
mut
[
$int_type
]
as
*
mut
[
Self
])
}
}
/// Consumes the atomic and returns the contained value.
///
/// This is safe because passing `self` by value guarantees that no other threads are
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录