小编A-B*_*A-B的帖子

我想访问内核内部的性能计数器。我发现了很多在用户空间中使用性能计数器的方法，但是你能告诉我一些在内核空间中使用这些计数器的方法吗？

请不要指定工具名称，我想编写自己的代码，最好是内核模块。我使用的是内核为 3.18.1 的 Ubuntu。

例如，我想在某些数据结构中存储 Pid 到 Name 的映射。这样，我们就可以快速检查某个给定的 pid 是否已经存储。您能为此建议一些 linux 内核中的数据结构吗？

我问这个关于 Haswell 微架构（英特尔至强 E5-2640-v3 CPU）的问题。从CPU和其他资源的规格我发现有10个LFB，超级队列的大小是16。我有两个关于LFB和SuperQueue的问题：

1) 系统可以提供的最大内存级并行度是多少，10 还是 16（LFB 或 SQ）？

2）根据某些来源，每个 L1D 未命中都记录在 SQ 中，然后 SQ 分配行填充缓冲区，而在其他某些来源中，他们写道 SQ 和 LFB 可以独立工作。你能简单解释一下 SQ 的工作吗？

这是 SQ 和 LFB 的示例图（不适用于 Haswell）。 参考资料：https : //www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf

http://www.realworldtech.com/haswell-cpu/

我试图了解 Rust 中的堆栈溢出处理程序。recursive_stack()我编写了一次又一次声明一些局部变量的函数以耗尽堆栈空间。

extern crate nix;

use nix::sys::signal;

extern "C" fn handle_sigsegv(_: i32) {
    //Do something here
}

fn main() {
    let sig_action = signal::SigAction::new(
        signal::SigHandler::Handler(handle_sigsegv),
        signal::SaFlags::SA_NODEFER,
        signal::SigSet::empty(),
    );
    unsafe {
        signal::sigaction(signal::SIGSEGV, &sig_action);
    }
    println!("Before function");
    recursive_stack();
    println!("After function");
}

fn recursive_stack() {
    let _array: [i64; 50] = [0; 50];
    recursive_stack();
}

我想捕获信号并执行我的信号处理程序。如果我注册信号处理程序，我会收到“分段错误（核心已转储）”消息。如果我不注册信号处理程序，则会收到堆栈溢出消息。

如果我将其注册为信号，则该信号处理程序工作正常SIGINT，但会给出奇怪的结果SIGSEGV。我缺少什么？

我在 Ubuntu 18.04 上运行这个程序。

我正在尝试为泛型类型动态分配内存，并希望将泛型类型包装在 Arc 中。但是，我遇到了分段错误。

当我将Tin包装起来时，代码运行良好Box，这意味着代码在语义上没有问题。

此外，当我使用 时，代码工作正常Vec::with_capacity()，而不是使用动态分配内存alloc()。

struct Entry<T>
where
    T: Sized + Clone + Default,
{
    val: T,
}

struct Entries<'a, T>
where
    T: Sized + Clone + Default,
{
    vec: &'a [Cell<Entry<T>>],
    index: usize,
}

impl<'a, T> Entries<'a, T>
where
    T: Sized + Clone + Default,
{
    fn new<'b>() -> Entries<'b, T> {
        let bytes = 64;
        let mem = unsafe {
            alloc(Layout::from_size_align(bytes, align_of::<Cell<Entry<T>>>()).expect("Error"))
        };

        let num = bytes / size_of::<Cell<Entry<T>>>(); …

我将原始指针传递给两个不同的闭包，并将原始指针转换为使用引用Box::from_raw()，程序运行正常。

但是，在将原始指针转换为引用后，析构函数应自动调用，如文档所述：

这个函数是不安全的，因为使用不当可能会导致内存问题。例如，如果函数在同一个原始指针上被调用两次，则可能会发生双重释放。

但是，即使在Box::from_raw()两次调用原始指针之后，我也能够访问对 ABC 的引用，并且它工作正常。

struct ABC {}

impl ABC {
    pub fn new() -> ABC {
        ABC {}
    }

    pub fn print(&self, x: u32) {
        println!("Inside handle {}", x);
    }
}

fn main() {
    let obj = ABC::new();
    let const_obj: *const ABC = &obj;

    let handle = |x| {
        let abc = unsafe { Box::from_raw(const_obj as *mut ABC) };
        abc.print(x);
    };
    handle(1);

    let handle1 = |x| {
        let abc = unsafe { Box::from_raw(const_obj as …