小编Ale*_*lex的帖子

例如,在标准C11和C++ 11中,有6种类型的内存屏障:http://en.cppreference.com/w/cpp/atomic/memory_order

• memory_order_relaxed
• memory_order_consume
• memory_order_acquire
• memory_order_release
• memory_order_acq_rel
• memory_order_seq_cst

哪些是确定编译器可以重新排序指令的方向,以及哪些处理器指令需要插入以限制处理器的流水线中的重新排序.例如,前五个障碍仅影响编译器,但不生成任何CPU指令(否S/L/ MFENCE),因为在x86中 - 自动提供acquire-release-semantics.

Java中有多少种类型的内存屏障？或者只有两种类型？

• 允许所有重新排序
• 禁止所有重新排序

为什么C ++编译器可以将函数声明为constexpr，而不能将其声明为constexpr？

例如：http : //melpon.org/wandbox/permlink/AGwniRNRbfmXfj8r

#include <iostream>
#include <functional>
#include <numeric>
#include <initializer_list>

template<typename Functor, typename T, size_t N>
T constexpr reduce(Functor f, T(&arr)[N]) {
  return std::accumulate(std::next(std::begin(arr)), std::end(arr), *(std::begin(arr)), f);
}

template<typename Functor, typename T>
T constexpr reduce(Functor f, std::initializer_list<T> il) {
  return std::accumulate(std::next(il.begin()), il.end(), *(il.begin()), f);
}

template<typename Functor, typename T, typename... Ts>
T constexpr reduce(Functor f, T t1, Ts... ts) {
  return f(t1, reduce(f, std::initializer_list<T>({ts...})));
}

int constexpr constexpr_func() { return 2; }

template<int value>
void print_constexpr() …

众所周知,DNN的主要问题是学习时间长.

但是有一些方法可以加速学习:

1. 批量标准化 =(x-AVG)/Variance:https://arxiv.org/abs/1502.03167

批量标准化实现了相同的准确度,培训步骤减少了14倍

2. ReLU =max(x, 0) - 整流线性单元(ReLU,LReLU,PReLU,RReLU):https://arxiv.org/abs/1505.00853

使用非饱和激活函数的优点在于两个方面:第一个是解决所谓的"爆炸/消失梯度".第二是加快收敛速度.

或者任何一个:( maxout,ReLU-family,tanh)

3. 快速权重初始化(避免消失或爆炸渐变):https://arxiv.org/abs/1511.06856

我们的初始化与标准计算机视觉任务(例如图像分类和物体检测)上的当前最先进的无监督或自我监督的预训练方法相匹配,同时大约快三个数量级.

或LSUV初始化(层序单位方差):https://arxiv.org/abs/1511.06422

但是如果我们使用所有步骤:(1)批量标准化,(2)ReLU,(3)快速权重初始化或LSUV - 那么在训练深度神经网络的任何步骤中使用自动编码器/自动关联器是否有任何意义？

众所周知,如果执行线程大于处理器核心数,则线程在某些时隙(量子)之间在它们之间切换.这适用于Win/*nix.但是,为线程切换实现了什么机制,它是在特定时隙启动的硬件中断,不是吗？

这个中断(IRQ)是多少,我可以更改/设置此时间的值(时隙),以及如何在短时间内关闭此中断,以获得对性能(实时)部分代码的关键性(通过使用WINAPI/Posix)？

什么是FPGA（Xilinx Virtex 5/7）上的执行线程，理论上它可以有多少个（最小和最大）？

我可以在Linux驱动程序(内核空间)中使用#include <stdatomic.h>和atomic_thread_fence()使用memory_orderC11,还是必须使用内存屏障的Linux功能:

• http://lxr.free-electrons.com/source/Documentation/memory-barriers.txt
• http://lxr.free-electrons.com/source/Documentation/atomic_ops.txt

使用:

• Linux内核2.6.18或更高版本
• GCC 4.7.2或更高版本

如上所述:如何减少CUDA同步延迟/延迟

设备等待结果有两种方法:

• "轮询" - 在旋转中刻录CPU - 在等待结果时减少延迟
• "阻塞" - 线程正在休眠直到发生中断 - 以提高一般性能

对于"轮询"需要使用CudaDeviceScheduleSpin.

但对于"堵"是什么,我需要使用CudaDeviceScheduleYield或cudaDeviceScheduleBlockingSync？

cudaDeviceScheduleBlockingSync和之间有什么区别cudaDeviceScheduleYield？

cudaDeviceScheduleYield如下所示:http://developer.download.nvidia.com/compute/cuda/4_1/rel/toolkit/docs/online/group__CUDART__DEVICE_g18074e885b4d89f5a0fe1beab589e0c8.html "指示CUDA 在等待设备结果时产生其线程.这可能会增加等待设备时的延迟,但可以提高与该设备并行执行工作的CPU线程的性能." - 即在旋转中没有刻录CPU的等待结果 - 即"阻塞".和cudaDeviceScheduleBlockingSync一样 - 等待结果没有刻录CPU旋转.但有什么区别？

例如，当我使用带有CUDA C / C ++和GPUDirect 2.0 P2P的多GPU系统，并且使用嵌套的PCI-Express开关时，如图所示，那么我必须通过其PCI总线ID知道任意两个GPU之间有多少个开关，以优化数据的传输和分配计算。

或者，如果我已经知道具有PCIe开关的硬件PCIe拓扑，那么我必须知道，任何GPU卡都连接到板上的哪个硬件PCIe插槽。

据我所知，即使我已经知道带有PCIe交换机的硬件PCIe拓扑，这些标识符也不会硬绑定到板上的PCIe插槽，并且这些ID可能会发生变化，并且因系统运行而异：

• CUDA device_id
• nvidia-smi / nvml GPU ID
• PCI总线ID

在Windows和Linux上，通过详细的设备树和板上的PCIe插槽数量发现PCIe总线拓扑的最佳方法是什么？

标准C++ 11是否保证在开始执行函数之前已经创建了所有3个临时对象？

即使临时对象传递为:

1. 宾语
2. 右值引用
3. 只传递临时对象的成员

http://ideone.com/EV0hSP

#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 << ", " << val << std::endl;
    std::cout << "func-end \n";
}

int main() {

    function(T(), T(), T().val);

    return 0;
}

输出:

T created …

\n
• 众所周知，在 x86_64 上，如果 Store 和 Load 之间没有，则可以进行 Store-Load 重新排序MFENCE。
\n

Intel\xc2\xae 64 和 IA-32 架构

\n

8.2.3.4 可以将早期存储的负载重新排序到不同位置

\n

\n
• 还已知，在这样的示例中可以是存储加载重新排序
\n

c.store(relaxed)<--> b.load(seq_cst)：https ://stackoverflow.com/a/42857017/1558037

// Atomic load-store\nvoid test() {\n    std::atomic<int> b, c;\n    c.store(4, std::memory_order_relaxed);          // movl 4,[c];\n    int tmp = b.load(std::memory_order_seq_cst);    // movl [b],[tmp];\n}\n

可以重新排序为：

// Atomic load-store\nvoid test() {\n    std::atomic<int> b, c;\n    int tmp = b.load(std::memory_order_seq_cst);    // movl [b],[tmp];\n    c.store(4, std::memory_order_relaxed);          // movl 4,[c];\n}\n