RUST应用程序正在退出，错误代码为：(退出代码：0xc0000005，STATUS_ACCESS_VIOLATION)

format!()创建一个新的String，这意味着分配.因此，您递归地调用分配器，直到获得堆栈溢出.

有多种方法可以解决这个问题:使用预分配的缓冲区并确保不分配，直接使用系统分配器进行分配，调用libc分配器...

你也不能在分配器内部panic ，因为it's UB if the allocator unwinds.您也不能在内部打印，因为运行库可能会在启动时在打印准备好之前进行分配.

一般来说，自定义分配器需要对它们调用的代码非常谨慎.我不认为你可以安全地使用std或alloc中的任何东西，只有core或直接拨打libc.

以下是一个如何使用libc和堆栈缓冲区而不是分配API来安全地完成此操作的示例:

unsafe impl GlobalAlloc for ReportingAllocator {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let start = Instant::now();
        let ptr = System.alloc(layout);
        let end = Instant::now();
        let time_taken = end - start;
        let time_taken = time_taken.as_nanos();
        let mut io_buffer = [0u8; 100];
        let mut io_buffer_tmp = &mut io_buffer[..];
        let bytes_requested = layout.size();
        // Do not `unwrap()` here!
        _ = writeln!(io_buffer_tmp, "{}, {}", time_taken, bytes_requested);
        let spare_len = io_buffer_tmp.len();
        let written_len = io_buffer.len() - spare_len;
        let io_buffer = &io_buffer[..written_len];

        let file = libc::fopen(
            b"src/log_data.csv\0".as_ptr().cast::<libc::c_char>(),
            "a\0".as_ptr().cast::<libc::c_char>(),
        );
        if !file.is_null() {
            libc::fwrite(
                io_buffer.as_ptr().cast::<libc::c_void>(),
                std::mem::size_of::<u8>(),
                io_buffer.len(),
                file,
            );
            libc::fclose(file);
        }

        return ptr;
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) -> () {
        System.dealloc(ptr, layout);
    }
}

当然，更有效的方法是缓存文件句柄，而更有效的方法是将数据存储在内存中，并且只在一段时间内将其批量写入文件.