小编Ale*_*lex的帖子

我想在映射内存上使用零拷贝cudaHostGetDevicePointer.我可以使用thrust::host_vector或者必须使用cudaHostAlloc(...,cudaHostAllocMapped)? 或者它是否更容易使用Thrust？

是否有工具将C++中的源代码转换为C/C++中的源代码,但是使用实例化(展开)模板？这对于明确理解C++模板转换的代码是必要的.可能它存在于IDE(MSVS,QtCreator,...)或编译器(ICC,GCC,MSVC,Clang)中？

通过使用内存标记为WB指令之间的主要区别是什么(回写)和WC(写入合并):什么是之间的不同MOVDQA和MOVNTDQA,什么是之间的不同VMOVDQA和VMOVNTDQ？

是不是对于内存标记为WC - 指令与[NT]通常没有区别(没有[NT]),并且内存标记为WB - 指令[NT]与它一起工作就好像它是一个内存WC？

当我想通过设置 PAT（页面属性表 - PTE 中的 7 位）将内存区域标记为写入组合（禁用可缓存并使用 BIU）或不可缓存时，那么我必须使用什么，这两个函数之间有什么区别?

• 驱动程序应该使用ioremap_[uc|wc][uc|wc] 访问类型来访问 PCI BAR：void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
• 驱动程序应该用于set_memory_[uc|wc]设置 RAM 范围的访问类型：int set_memory_uc(unsigned long addr, int numpages)

摘自：http : //lwn.net/Articles/278994/

为什么我不能对 PCI BAR 和 RAM 范围使用相同的单一功能？

澄清：ioremap_uc()获取物理地址并返回虚拟地址 是否设置为 Uncacheable，而set_memory_uc()哪个获取虚拟地址并为这些页面设置 Uncacheable？

这些代码相等吗？

void* virt_ptr = ioremap_uc(phys_ptr, size);

和

void* virt_ptr = ioremap(phys_ptr, size);
const int page_size = 4096;
set_memory_uc(virt_ptr, size/page_size);

什么是不同的功能:malloc()和kmalloc()？它们的区别仅在于:

• 在malloc()可以在用户空间和内核空间被调用,它分配一个物理上分散的存储区域
• 但kmalloc()只能在内核空间中调用,并且它会分配物理上连续的内存块

或者是其他东西？

kmalloc()在虚拟或物理寻址中使用指针有什么kmalloc()不同__ get_free_pages()？

众所周知,标准C++ 11保证传递给函数的临时对象将在函数调用之前创建:标准C++ 11是否保证在函数调用之前创建传递给函数的临时对象？

但是,标准C++ 11是否保证传递给函数的临时对象在函数结束后(之前没有)被销毁？

工作草案,编程语言标准C++ 2016-07-12:http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4606.pdf

§12.2临时对象

§12.2/ 5

有三种情况下,临时表在与完整表达结束时不同的点被摧毁.第一个上下文是调用默认构造函数来初始化没有相应初始值设定项的数组元素(8.6).第二个上下文是在复制整个数组时调用复制构造函数来复制数组的元素(5.1.5,12.8).在任何一种情况下,如果构造函数具有一个或多个默认参数,则在构造下一个数组元素(如果有)之前,对默认参数中创建的每个临时的销毁进行排序.第三个上下文是引用绑定到临时的.

也:

§1.9/ 10

甲全表达为不是另一种表达的子表达式的表达式.[注意:在某些情况下,例如未评估的操作数,语法子表达式被视为完整表达式(第5条). - 结束注释]如果定义语言构造以产生函数的隐式调用,则语言构造的使用被认为是用于该定义目的的表达式.在临时对象以外的对象的生命周期结束时生成的析构函数的调用是隐式的完整表达式.应用于表达式结果的转换以满足表达式出现的语言构造的要求也被认为是完整表达式的一部分.

这是否意味着标准C++ 11保证传递给函数的临时对象不会在函数结束之前被破坏 - 并且恰好在完整表达式的末尾？

http://ideone.com/GbEPaK

#include <iostream>
using namespace std;

struct T { 
    T() { std::cout << "T created \n"; }
    int val = 0;
    ~T() { std::cout << "T destroyed \n"; }
};

void function(T t_obj, T &&t, int &&val) {
    std::cout << "func-start \n";
    std::cout << t_obj.val << ", " << t.val << ", …

众所周知，PowerPC具有较弱的内存模型，它允许进行任何推测性的重新排序：存储-存储，加载-存储，存储-加载，加载-加载。

至少有3个栅栏：

• hwsync或sync-完整的内存屏障，防止任何重新排序
• lwsync -防止重新排序的内存屏障：加载，加载，存储，加载
• isync- 指令障碍：https : //www.ibm.com/support/knowledgecenter/zh-CN/ssw_aix_71/com.ibm.aix.alangref/idalangref_isync_ics_instrs.htm

例如，是否可以在此代码中重新排序“存储stwcx.和加载” lwz？：https : //godbolt.org/g/84t5jM

    lwarx 9,0,10
    addi 9,9,2
    stwcx. 9,0,10
    bne- 0,.L2
    isync
    lwz 9,8(1)

如已知的，isync防止重新排序lwarx，bne< - > any following instructions。

但是是否可以isync防止重新排序stwcx.，bne<-> any following instructions？

即可以先stwcx.于以下Load-开始存储lwz，而比Load-之后执行完成lwz。

即可以stwcx.将存储库预执行的存储早于随后的加载lwz开始存储到存储缓冲区，但是对所有CPU内核可见的实际存储到高速缓存的发生要晚于加载lwz完成？

我们从以下文档，文章和书籍中看到：

• isync 不是内存围栏，而仅仅是指令围栏。

• isync 对于访问存储器的其他处理器和机制，并不强制完成所有外部访问。

• isync 不等待所有其他处理器检测到存储访问

• isync …

众所周知，如果我们将元素 push_back 到std::vector<>，并且如果向量中分配的整个内存都被占用，则std::vector<>保留当前内存大小的 2X（分配 2X 大小的新内存），调整向量大小并将旧数据复制到新内存。

我们可以优化它，Facebook 在 folly-library 中做到了这一点（FBVector 是 Facebook 对 std::vector 的直接实现。它有特殊的优化用于可重定位类型和 jemalloc https://github.com/facebook/folly/ blob/master/folly/FBVector.h#L21）。

即当vector<>没有足够的内存来 push_back 新元素时，然后我们分配更多的内存，但不会增加 2 倍（不同的次数：1.3 - 1.5 次）

说明：https : //github.com/facebook/folly/blob/master/folly/docs/FBVector.md

下面的图形求解器显示，选择 k = 1.5（蓝线）允许在 4 次重新分配后重用内存，选择 k = 1.45（红线）允许在 3 次重新分配后重用内存，选择 k = 1.3（黑线）允许仅在 2 次后重用重新分配。

但是为什么我们需要使用folly::fbvector<>而不是std::vector<>使用我们的自定义分配器VirtualAllocEx()（如下所示：我需要使用 VirtualAlloc/VirtualAllocEx 的原因是什么？），或者在 linux 中使用相同的/sf/answers/194803731/ 1558037，其中：

• std::vector<>::reserve() - 最初保留大量未提交的虚拟地址区域（分配 WMA，但在 PT 中不分配任何 PTE），例如最初分配 16 GB …

在 Linux x86_64 内核 3.16 上处理网络数据包时，可以在不同的 CPU 内核上执行相同网络数据包的硬和软 IRQ 吗？

• Hard-IRQ 引发 Soft-IRQ：http : //she-devel.com/Chaiken_ELCE2016.pdf

  软 IRQ 可以在引发它们的硬 IRQ 之后直接运行，或者稍后在 ksoftirqd 中运行。

• RSS在与 Hard-IRQ 相同的 CPU-Core 上引发Soft-IRQ：http : //balodeamit.blogspot.ru/2013/10/receive-side-scaling-and-receive-packet.html

  在多队列 (RSS) 的情况下，硬件中断将转到匹配的 CPU 处理器，该处理器还将负责 softIRQ 处理。

• 在单队列的情况下，没有 RPS，Soft-IRQ 在与 Hard-IRQ 相同的 CPU-Core 上处理，但使用 RPS，Soft-IRQ 在另一个 CPU-Core 上处理而不是 Hard-IRQ：http : //balodeamit.blogspot.ru /2013/10/receive-side-scaling-and-receive-packet.html

  在单队列的情况下，产生的硬件中断来自单个队列，同一个 CPU 也负责处理 softIRQ。如果在单声道队列上启用 RPS，传入的数据包将被散列，负载分布在多个 CPU 处理器上。

• RPS 在其他 CPU 核心上提高 Soft-IRQ 而不是 Hard-IRQ，它增加了处理器间中断 (IPI) 的速率：https ://en.wikipedia.org/wiki/Interrupt#Performance_issues …

我可以多次使用相同的std::promise和std::future对象吗？

例如，我想将多个值从 Thread-1 多次发送到 Thread-2。我可以多次使用 promise/future，以及如何做到线程安全？

            std::promise<int> send_value;
            std::future<int> receive_value = send_value.get_future();

            std::thread t1 = std::thread([&]()
            {
                while (!exit_flag) {
                    int value = my_custom_function_1();
                    send_value.set_value(value);
                }
            });

            std::thread t2 = std::thread([&]()
            {
                while (!exit_flag) {
                    int value = receive_value.get();
                    my_custom_function_2(value);
                }
            });