小编use*_*080的帖子

请考虑以下代码段:

#include <iostream>

struct A {
  A() {}
  A(const A&) {}
};

struct B {
  B(const A&) {}
};

void f(const A&) { std::cout << "A" << std::endl; }
void f(const B&) { std::cout << "B" << std::endl; }

int main() {
  A a;
  f(   {a}   ); // A
  f(  {{a}}  ); // ambiguous
  f( {{{a}}} ); // B
  f({{{{a}}}}); // no matching function
}

为什么每个调用都会编写相应的输出？支撑数如何影响均匀初始化？支撑精益如何影响这一切？

OpenMP有自己的原子访问支持,但是,至少有两个理由更喜欢C++ 11原子:它们更灵活,它们是标准的一部分.另一方面,OpenMP比C++ 11线程库更强大.

该标准在两个不同的章节中指定了原子操作库和线程支持库.这让我相信原子访问的组件与所使用的线程库是正交的.我确实可以将C++ 11原子和OpenMP结合起来吗？

Stack Overflow上有一个非常类似的问题 ; 然而,它已经基本上没有答案三年了,因为它的答案并没有回答实际的问题.

我认为我对MapReduce编程模型有一般的了解,但即使在阅读了原始论文和其他一些资料之后,我也不清楚许多细节,特别是关于中间结果的分区.

到目前为止,我将快速总结一下我对MapReduce的理解:我们有一个非常大的输入数据集,它由MR-Framework自动分成M个不同的部分.对于每个部分,框架调度一个映射任务,该任务由我的集群中的一个可用处理器/机器执行.M个映射任务中的每一个输出一组键值对,其本地存储在执行该映射任务的同一机器上.每台机器将其磁盘划分为R个分区,并根据分区之间的中间密钥分配其计算的中间密钥值对.然后,框架为每个不同的中间密钥启动一个reduce任务,该任务再次由任何可用的机器执行.

现在我的问题是:

1. 在一些教程中,听起来可能有并行执行的map和reduce任务.这是正确的吗？怎么可能,假设每个不同的中间密钥只开始一个reduce任务？在我们开始第一个reduce任务之前,我们不必等到最后一个map任务完成吗？
2. 由于每个不同的中间密钥有一个reduce任务,每个reduce任务是否需要执行机器从其他每台机器加载相应的分区？潜在地,每台机器都可以具有带有所需中间密钥的键值对,因此对于每个reduce任务,我们可能必须查询所有其他机器.这真的很有效吗？
3. 原始文件说,分区数(R)由用户指定.但是不是分区输入的减少任务吗？或者更确切地说:在一台减少任务的输入中,并非所有机器中具有相同编号的所有分区的并集？这意味着,R取决于用户通常不知道的不同中间密钥的数量.

从概念上讲,很清楚地图的输入和输出以及减少功能/任务是什么.但我认为我还没有在技术层面上理解MapReduce.有人可以帮我理解吗？

使用EclipseLink作为JPA 2.0提供程序,我只需调用即可获得JDBC连接

Connection con = entityManager.unwrap(Connection.class);

但我不确定我应该对此负责.提交查询后是否必须关闭连接？或者我不允许关闭连接,因为EclipseLink也在内部使用此连接.或者它不在乎,因为如果我不这样做,EclipseLink会观察我的行为并自动关闭连接？

我有充分理解伽马校正需求的问题.我希望你们能帮助我.

假设我们想要显示256个相邻像素.这些像素应该是从黑到白的平滑渐变.为了表示它们的颜色,我们使用线性灰度值.0..255.由于人眼的非线性,显示器不能只将这些值转换为线性亮度值.如果相邻像素具有亮度值(1/256)*I_max, (2/256)*I_max, et cetera,我们将在较暗区域中感知到两个像素之间的亮度差异太大(梯度将不是平滑的).

幸运的是,监视器对人眼具有相互的非线性.这意味着,如果我们将线性灰度值0..255放入帧缓冲区,则监视器将它们转换为非线性亮度值x ^ gamma.然而,由于我们的眼睛是非线性的,反之亦然,我们感觉到平滑的线性梯度.显示器和我们的一只眼睛的非线性相互抵消.

那么,为什么我们需要伽马校正？我在书中读到,我们总是希望显示器产生线性亮度值.根据它们,必须在将灰度值写入帧缓冲器之前补偿监视器的非线性.这是通过伽马校正完成的.然而,我的问题在于 - 据我所知 - 当监视器产生线性亮度值时,我们不会感知线性亮度值(即我们不会感觉到平滑,稳定的梯度).

据我所知,如果我们将线性灰度值放入帧缓冲区,那将是完美的.监视器将这些值转换为非线性亮度值,并且我们的眼睛再次感知线性亮度值,因为眼睛是互逆的非线性.不需要对帧缓冲器中的灰度值进行伽马校正,也不需要强制监视器产生线性亮度值.

我看待这些事情的方式有什么问题？谢谢

如果我们有两个内核在同一个缓存块中读取和写入不同的内存位置，则两个内核都被迫一次又一次地重新加载该缓存块，尽管这在逻辑上是不必要的。这就是我们所说的虚假分享。

但是，如果内核从不从该缓存块读取，而只写入怎么办？想象一下，两个内核只是在同一个缓存块中设置了一些位，但它们不必从块中读取，因为它们设置的位信息仅在程序的后期阶段才需要。

是否仅当内核在同一个块上读写时才会发生错误共享，或者如果两者都只写入它也会发生？

我尝试使用std::enable_if未使用和未命名的类型参数,以免扭曲return类型.但是,以下代码无法编译.

#include <iostream>

template <typename T, typename = std::enable_if_t<!std::is_integral<T>::value>>
T foo() { std::cout << "non-integral" << std::endl; return T(); }

template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>>
T foo() { std::cout << "integral" << std::endl; return T(); }

int main() {
  foo<float>();
  foo<int>();
}

编译器说:

7:3: error: redefinition of 'template<class T, class> T foo()'
4:3: note: 'template<class T, class> T foo()' previously declared here
 In function 'int main()':
11:12: error: no matching function for call to 'foo()' …

函数模板专业化的主要模板通常非常直观,但是,我正在寻找正式的规则来理解更令人惊讶的情况.例如:

template <typename T, typename U>
void f(T, U) {}     // (1)

template <typename T>
void f(T, T) {}     // (2)

template <>
void f(int, int) {} // (3); specializes (2), not (1); why?

从理论上讲,(3)也可以是(1)的特化,但实验表明它不是.

由于C++标准在很多方面都非常模糊,我想从不同的编译器中查找具体的实现.目前,我想知道GCC如何分配和对齐位字段.

对于MS Visual C++编译器,它非常简单:用户手册中有一个关于位字段的精美页面,它解释了所有开放分配/对齐问题,甚至还有数字和示例.

我只想要GCC的相同信息,但似乎更复杂.GCC手册中有一页只是说"由ABI决定".然后我们有一些关于ABI策略和指南的信息,其中包含指向Github上名为Itanium C++ ABI的文档的链接.现在,在本文档中,我们可以找到以下内容:"根据底层C psABI的要求分配位域".这就是我被困住了.搜索C psABI时,我找不到有用的网站.

任何人都可以请我指向GCC的位域实现的网站吗？它不能那么复杂,不是吗？为什么GCC的文档往往比微软的文档复杂得多？我使用了错误的资源吗？

为什么thread_local不能应用于非静态数据成员？这个问题的接受答案是:"制作非静态结构或类成员线程本地没有意义." 老实说,我看到很多很好的理由让非静态数据成员成为线程本地的.

假设我们有一种ComputeEngine成员函数computeSomething,它被连续多次调用.成员函数内部的一些工作可以并行完成.为此,每个线程需要某种类型ComputeHelper,例如,辅助数据结构.所以我们真正想要的是以下内容:

class ComputeEngine {
 public:
  int computeSomething(Args args) {
    int sum = 0;
    #pragma omp parallel for reduction(+:sum)
    for (int i = 0; i < MAX; ++i) {
      // ...
      helper.xxx();
      // ...
    }
    return sum;
  }
 private:
  thread_local ComputeHelper helper;
};

不幸的是,这段代码无法编译.我们可以做的是:

class ComputeEngine {
 public:
  int computeSomething(Args args) {
    int sum = 0;
    #pragma omp parallel
    {
      ComputeHelper helper;
      #pragma omp for reduction(+:sum)
      for (int i …