小编ein*_*ica的帖子

_{（接着这个问题：）}

void foo() {
    constexpr const auto my_lambda = [](int z) { return z+1; };
}

显然，my_lambda“不是静态的”。除了没有正式定义之外，在什么意义上它不是静态的？为什么它不应该是隐式静态的，看看它似乎符合定义？

令人兴奋的 的存储库mdspan是为 C++ 标准库建议的多维类似物std::span，现在还包含密切相关的 的参考实现mdarray，与mdspan拥有其数据不同。

但是，尽管该submdspan函数可以生成 的子集mdspan，但我找不到 的类似物mdarray。submdspan我期待的是一个行为与返回完全相同的函数mdspan，但它对 进行操作mdarray。

这是有计划但尚未实施吗？如果没有，为什么不呢？

编辑：

我已经用自制解决方案暂时解决了这个问题，其形式是重载submdspan，mdarray然后创建一个映射mdspan到整个 的临时文件mdarray，并调用submdspan它。

现在它可以完成工作了！但我不确定这是否涵盖了所有可能的情况mdarray，因为目前几乎没有文档。仍然希望得到原来问题的答案。

template <class ElementType, class Extents, class LayoutPolicy, class... SliceSpecs>
auto submdspan(
    mdarray<ElementType, Extents, LayoutPolicy> &arr, 
    SliceSpecs... slices)
{
    return submdspan(
        mdspan<ElementType, Extents, LayoutPolicy>(arr.data(), arr.mapping()), 
        slices...);
}

如何打印字符串的位表示

std::string = "\x80";

void print (std::string &s) {

    //How to implement this
}

std::vector<std::string> endpointLSRKey;

for(auto it = endpointLSRKey.begin(); it != endpointLSRKey.end(); ++it) {
        lsr->setItem(0, "", *it, address);
    }

然后得到一个错误说"auto"改变了c ++ 11中的含义,删除它!

所以我改变它:

for(std::string& str : endpointLSRKey){
        lsr->setItem(0, "", str, address);
    }

然后得到一个错误说"在C++ 98模式下不允许'循环'基于范围"

完全糊涂了,如何迭代它？

为什么有时它是c ++ 11而有时它是c ++ 98？

关于Cuda流处理多个内核的几个问题.在具有3.5个功能的kepler设备中假设s流和内核,其中s <= 32.内核使用大小为n的dev_input数组和大小为s*n的dev输出数组.内核从输入数组中读取数据,将其值存储在寄存器中,对其进行操作并将其结果写回位于s*n + tid的dev_output.

我们的目标是每次使用n个流中的一个来运行相同的内核.与simpleHyperQ示例类似.你能否评论以下任何一项是否以及如何影响并发？

1. dev_input和dev_output没有固定;
2. dev_input因为它是vs dev_input size s*n,其中每个内核读取唯一数据(没有读取冲突)
3. 内核从常量内存中读取数据
4. 每个块分配10kb的共享内存.
5. 内核使用60个寄存器

任何好的评论将不胜感激...... !!!

欢呼,Thanasio

罗伯特,非常感谢你的详细解答.这非常有帮助.我编辑了4,每块10kb.所以在我的情况下,我发布了61个块和256个线程的网格.内核受计算限制.我启动了8个相同内核的流.描述它们然后我看到前两个之间非常好的重叠然后它变得越来越糟.内核执行时间约为6ms.在前两个流执行几乎完全并发后,其余的流之间的距离为3ms.关于5,我使用具有255寄存器文件的K20.所以我不希望那里有弊端.我真的不明白为什么我没有达到相当于为gk110s指定的并发性.

请看下面的链接.有一个名为kF.png的图像.它显示了流的分析器输出.. !!!

https://devtalk.nvidia.com/default/topic/531740/cuda-programming-and-performance/concurrent-streams-and-hyperq-for-k20/

我有以下代码从主机变量复制到__constant__CUDA中的变量

int main(int argc, char **argv){

    int exit_code;

    if (argc < 4) {
        std::cout << "Usage: \n " << argv[0] << " <input> <output> <nColors>" << std::endl;
        return 1;
    }

    Color *h_input;
    int h_rows, h_cols;

    timer1.Start();
    exit_code = readText2RGB(argv[1], &h_input, &h_rows, &h_cols);
    timer1.Stop();
    std::cout << "Reading: " << timer1.Elapsed() << std::endl;

    if (exit_code != SUCCESS){
        std::cout << "Error trying to read file." << std::endl;
        return FAILURE;
    }

    CpuTimer timer1;
    GpuTimer timer2;
    float timeStep2 = 0, timeStep3 = 0; …

我已经阅读了关于访问器方法的3种不同约定的社区wiki查询,并且看到以下约定并不令人惊讶:

const unsigned& amount() const { return _amount; }
unsigned& amount() { return _amount; }

是的,它与无缝的完全不同,因为它能够完全避免括号() - 这会(我觉得)是想法 - 但它仍然是某种东西; 对？

我使用atomicInc()尝试过以下程序.

__global__ void ker(int *count)
{
    int n=1;
    int x = atomicInc ((unsigned int *)&count[0],n);
    CUPRINTF("In kernel count is %d\n",count[0]);
}

int main()
{
    int hitCount[1];
    int *hitCount_d;

    hitCount[0]=1;
    cudaMalloc((void **)&hitCount_d,1*sizeof(int));

    cudaMemcpy(&hitCount_d[0],&hitCount[0],1*sizeof(int),cudaMemcpyHostToDevice);

    ker<<<1,4>>>(hitCount_d);

    cudaMemcpy(&hitCount[0],&hitCount_d[0],1*sizeof(int),cudaMemcpyDeviceToHost);

    printf("count is %d\n",hitCount[0]);
  return 0;
}

输出是:

In kernel count is 1
In kernel count is 1
In kernel count is 1
In kernel count is 1

count is 1

我不明白为什么它没有递增.谁能帮忙

我的CUDA应用程序具有小于8KB的恒定内存.由于它都将被缓存,我是否需要担心每个线程访问相同的地址以进行优化？

如果是,我如何确保所有线程同时访问同一地址？

erase()和之间有什么区别remove()？

• std::whatever::erase - 获取范围迭代器(first-last),并匹配所有元素.
• std::remove - 获取范围迭代器(first-last)和匹配删除的值.

除此之外,看起来他们做同样的事情.即在两种情况下实际的"擦除"或"移除"都是相同的(除非我弄错了).那么,为什么其中一个是(矢量,集合,映射等)方法,另一个是自由浮动函数？

笔记:

• 是的,我知道还有一个erase()需要一个迭代器,但你也可以std::remove()使用相同的语义.