Skip to content

Simplify the unix Weak functionality #58442

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Feb 24, 2019
Merged

Simplify the unix Weak functionality #58442

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
70c5af8
Avoid allocation in std::sys::unix::weak
cuviper Feb 13, 2019
33d80bf
Return without a reference in unix Weak::get()
cuviper Feb 13, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
15 changes: 7 additions & 8 deletions src/libstd/sys/unix/weak.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,15 +18,15 @@

use libc;

use ffi::CString;
use ffi::CStr;
use marker;
use mem;
use sync::atomic::{AtomicUsize, Ordering};

macro_rules! weak {
(fn $name:ident($($t:ty),*) -> $ret:ty) => (
static $name: ::sys::weak::Weak<unsafe extern fn($($t),*) -> $ret> =
::sys::weak::Weak::new(stringify!($name));
::sys::weak::Weak::new(concat!(stringify!($name), '\0'));
)
}
Copy link
Member

@RalfJung RalfJung Feb 23, 2019 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Shouldn't something about this abstraction be unsafe? Like, either the constructor or get or so?

Seems we are using it only with unsafe fn, but the Weak type itself can't know that.

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Sure, I think it would make sense for the constructor to be unsafe, which the macro can hide knowing this is unsafe fn. All uses do go through this macro already though.


Expand All @@ -45,23 +45,22 @@ impl<F> Weak<F> {
}
}

pub fn get(&self) -> Option<&F> {
pub fn get(&self) -> Option<F> {
assert_eq!(mem::size_of::<F>(), mem::size_of::<usize>());
unsafe {
if self.addr.load(Ordering::SeqCst) == 1 {
self.addr.store(fetch(self.name), Ordering::SeqCst);
}
if self.addr.load(Ordering::SeqCst) == 0 {
None
} else {
mem::transmute::<&AtomicUsize, Option<&F>>(&self.addr)
match self.addr.load(Ordering::SeqCst) {
0 => None,
addr => Some(mem::transmute_copy::<usize, F>(&addr)),
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Please add a comment saying that the sizes are equal because we asserted this earlier. (Took me a bit to see that. As I said, I don't know this code and feel somewhat uncomfortable reviewing it.)

}
}
}
}

unsafe fn fetch(name: &str) -> usize {
let name = match CString::new(name) {
let name = match CStr::from_bytes_with_nul(name.as_bytes()) {
Ok(cstr) => cstr,
Err(..) => return 0,
};
Expand Down