如果它们是同一个类的实例,它们的大小是相同的,使用sun.misc.Unsafe,我可以覆盖一个obejct与另一个obejct吗？
编辑:通过"覆盖"我的意思是"删除"第一个对象,蚂蚁用第二个填充内存.可能吗？
我正在开发类似于sun.misc.Unsafe的JNI实现,但具有扩展的内存管理.
如何从sun.misc.Unsafe和我开发的库中解释本机方法的调用时间是非常不同的？
一些数字:sun.misc.Unsafe.getInt(地址)需要〜1ns,当我的类似方法需要~10ns
两个实现完全相同,遵循openJDK的源代码,只是通过指针返回变量.在JNI模块中不安全,以与其他模式相同的方式注册.
如何加快JNI通话？是什么让Unsafe对性能如此特别？
谢谢,Yury /
如何在C#中声明结构类型的固定大小数组:
[StructLayout(LayoutKind.Sequential,Pack=1), Serializable]
public unsafe struct MyStruct{
...
}
public class MyClass {
...
public fixed MyStruct myStruct[256];
}
这将导致CS1663:不允许使用结构类型的固定大小缓冲区,我该如何解决这个问题？我不喜欢使用C#或"托管集合数据结构"类型,因为我需要经常将其编译为本机C++
现在提交Microsoft Connect ; 如果您觉得需要修理请立即投票.我也简化了测试用例:
byte* data = (byte*) 0x76543210;
uint offset = 0x80000000;
byte* wrong = data + offset;
byte* correct = data + (uint) 0x80000000;
// "wrong" is now 0xFFFFFFFFF6543210 (!)
// "correct" is 0xF6543210
看看IL,就我所知,C#编译器做的一切都正确,错误在于JITter.
原始问题:这里发生了什么？
byte* data = (byte*)Marshal.AllocHGlobal(0x100);
uint uioffset = 0xFFFF0000;
byte* uiptr1 = data + uioffset;
byte* uiptr2 = data + (uint)0xFFFF0000;
ulong uloffset = 0xFFFF0000;
byte* ulptr1 = data + uloffset;
byte* ulptr2 = data + (ulong)0xFFFF0000;
Action<string, ulong> dumpValue = …Pipes当有多个发送者和接收者时,我不明白为什么说不安全.
Queues如果是这种情况,如何将以下代码转换为代码？关闭时Queues不要抛出EOFError,所以我的进程无法停止.我是否应该无休止地发送"Poison"消息告诉他们停止(这样,我确定我的所有进程都至少收到一个毒药)？
我想保持管道p1打开,直到我另有决定(这是我发送10条消息的时候).
from multiprocessing import Pipe, Process
from random import randint, random
from time import sleep
def job(name, p_in, p_out):
print(name + ' starting')
nb_msg = 0
try:
while True:
x = p_in.recv()
print(name + ' receives ' + x)
nb_msg = nb_msg + 1
p_out.send(x)
sleep(random())
except EOFError:
pass
print(name + ' ending ... ' + str(nb_msg) + ' message(s)')
if __name__ == '__main__':
p1_in, p1_out = Pipe()
p2_in, p2_out …据我所知,根据MSDN C#fixed语句应该像:
fixed (char* p = str) ... // equivalent to p = &str[0]
所以,为什么我不能这样做？
const string str = "1234";
fixed (char* c = &str[0])
{
/// .....
}
str[1]作为一个例子,我怎样才能得到指针？
在C中,我可以像这样定义一个指向数组的指针:
char b1[SOME_SIZE];
char (*b3)[3]=(char(*)[3])b1;
这样b3[i][j] == b1[i*3+j].
我可以b3在unsafeC#中声明这样的指针吗？
我的目的是访问位图通道:
///...
unsafe {
//...
byte *target; //8bpp
byte (*source)[3]; //24bpp
//...
target[x]=(source[x][0]+source[x][1]+source[x][2])/3;
//...
我希望这样,使用source[x][ch]而不是source[x*3+ch]获得一些编译器优化.
如果尝试使用该属性创建泛型结构,则使用该结构会在运行时生成异常:[StructLayout(LayoutKind.Explicit)]
System.TypeLoadException:无法从程序集"bar"加载类型'foo',因为泛型类型不能具有显式布局.
我一直很难找到任何证据证明这种限制甚至存在.该Type.IsExplicitLayout文档强烈暗示,它被允许和支持.有谁知道为什么不允许这样做？我想不出为什么泛型类型会使其不易验证的任何原因.作为一个边缘案例,它让我感到震惊,他们根本不愿意实施.
以下是显式通用布局有用的原因示例:
public struct TaggedUnion<T1,T2>
{
public TaggedUnion(T1 value) { _union=new _Union{Type1=value}; _id=1; }
public TaggedUnion(T2 value) { _union=new _Union{Type2=value}; _id=2; }
public T1 Type1 { get{ if(_id!=1)_TypeError(1); return _union.Type1; } set{ _union.Type1=value; _id=1; } }
public T2 Type2 { get{ if(_id!=2)_TypeError(2); return _union.Type2; } set{ _union.Type2=value; _id=2; } }
public static explicit operator T1(TaggedUnion<T1,T2> value) { return value.Type1; }
public static explicit operator T2(TaggedUnion<T1,T2> value) { return value.Type2; …在我的项目的相当低级的部分中，函数接收可变的原始数据切片（&mut [u32]在这种情况下）。此数据应以小端序写入作者。
现在，仅此一项就不成问题，但是所有这些必须快速。我评估了我的应用程序，并将其确定为关键路径之一。特别是，如果不需要更改字节序（因为我们已经在一个小的字节序系统上），那么就不会有任何开销。
这是我的代码（Playground）：
use std::{io, mem, slice};
fn write_data(mut w: impl io::Write, data: &mut [u32]) -> Result<(), io::Error> {
adjust_endianness(data);
// Is this safe?
let bytes = unsafe {
let len = data.len() * mem::size_of::<u32>();
let ptr = data.as_ptr() as *const u8;
slice::from_raw_parts(ptr, len)
};
w.write_all(bytes)
}
fn adjust_endianness(_: &mut [u32]) {
// implementation omitted
}
adjust_endianness更改位置的字节序（这很好，因为错误的字节序u32是垃圾，但仍然是有效的u32）。
该代码有效，但关键问题是：这样安全吗？特别是，在某个时刻，data并且bytes两者都存在，它们是同一数据的一个可变且一个不变的切片。听起来很不好，对吧？
另一方面，我可以这样做：
let bytes = &data[..];
这样，我也有这两个方面。所不同的只是 …