Another solution for this case is to move a mutable reference to the item into the thread, even though mutability isn’t required. Since there can be only one mutable reference, the compiler knows that it’s safe to be used in another thread. use crossbeam; // 0.7.3 use std::cell::RefCell; fn main() { let mut val = … Read more
When is this needed? Under what circumstances does using pointers becomes inevitable? When the net cost of a managed, safe solution is unacceptable but the net cost of an unsafe solution is acceptable. You can determine the net cost or net benefit by subtracting the total benefits from the total costs. The benefits of an … Read more
Whenever writing an unsafe block, I strongly encourage people to include a comment on the block explaining why you think the code is actually safe. That type of information is useful for the people who read the code in the future. Instead of adding comments about the “magic number” 4, just use mem::size_of::<u32>. I’d even … Read more
You can use a really ugly hack to temporary change your array to byte[] using memory manipulation. This is really fast and efficient as it doesn’t require cloning the data and iterating on it. I tested this hack in both 32 & 64 bit OS, so it should be portable. The source + sample usage … Read more
The obvious, safe and portable way is to just use math. fn set_u16_le(a: &mut [u8], v: u16) { a[0] = v as u8; a[1] = (v >> 8) as u8; } If you want a higher-level interface, there’s the byteorder crate which is designed to do this. You should definitely not use transmute to turn … Read more
There is a dirty fast (not unsafe code) way of doing this: [StructLayout(LayoutKind.Explicit)] struct BytetoDoubleConverter { [FieldOffset(0)] public Byte[] Bytes; [FieldOffset(0)] public Double[] Doubles; } //… static Double Sum(byte[] data) { BytetoDoubleConverter convert = new BytetoDoubleConverter { Bytes = data }; Double result = 0; for (int i = 0; i < convert.Doubles.Length / sizeof(Double); … Read more
Some Performance Measurements The performance benefits are not as great as you might think. I did some performance measurements of normal managed array access versus unsafe pointers in C#. Results from a build run outside of Visual Studio 2010, .NET 4, using an Any CPU | Release build on the following PC specification: x64-based PC, … Read more
Though there are times when you may want to do things similar to what you’re trying to accomplish here, they are a rarity. So most people reading this, maybe even OP, may wish to restructure such that struct state and data used for a single async execution are different objects. To answer your question, yes … Read more
Today the rayon crate is the de facto standard for this sort of thing: use rayon::prelude::*; fn main() { let mut data = vec![1, 2, 3]; data.par_iter_mut() .enumerate() .for_each(|(i, x)| *x = 10 + i as u32); assert_eq!(vec![10, 11, 12], data); } Note that this is just one line different from the single-threaded version using … Read more
This is clearly implementation-specific. Below I include the Object.hashCode() implementation used in OpenJDK 7. The function supports six different calculation methods, only two of which take any notice of the object’s address (the “address” being the C++ oop cast to intptr_t). One of the two methods uses the address as-is, whereas the other does some … Read more