小编pSo*_*oLT的帖子

我试图找出一个简单的CUDA设计问题的解决方案.假设我有一个处理数据的内核.如果当前处理的数据满足指定条件,则相应的元素outputArray获取当前计数器值并且计数器正在递增.

它看起来像这样:

__global__ void setTags(INDATA* inputData, int* tags)
{
    int blockId = blockIdx.x + blockIdx.y * gridDim.x;
    int threadId = blockId * (blockDim.x * blockDim.y) + (threadIdx.y * blockDim.x) + threadIdx.x;
    if(threadId < N)
    {
        INDATA current = inputData[threadId];
        if(/* current meets some criteria */)
        {
            tags[threadId] = /*current counter value */
            /* increment counter value */
        }
    }
}

符合标准的元素数量明显少于所有元素.关键是处理停留在GPU上,我的案例标记为唯一整数,范围从0到满足条件的案例数量 - 1.有没有比单线程中增量更快的方法？

我正在试图为周期性任务找出一个简单的调度程序.该想法是提供一种方法来安排std::function<void()>任何给定时间间隔的周期性执行,该时间间隔将是一秒的乘法.我试图使用boost :: asio来编写它,但到目前为止我最终会遇到奇怪的行为 - 只有两个计划任务中的一个被重复执行,但它不遵循间隔.

这是代码:

#include <functional>
#include <iostream>

#include <boost/asio.hpp>
#include <boost/bind.hpp>

class PeriodicTask
{
public: 
     PeriodicTask(boost::asio::io_service * ioService, int interval, std::function<void()> task)
     : ioService(ioService), 
       interval(interval), 
       task(std::make_shared<std::function<void()>>(task)),
       timer(std::make_shared<boost::asio::deadline_timer>(*ioService, boost::posix_time::seconds(interval)))
    {}

    void execute()
    {
        task->operator()();
        timer->expires_at(timer->expires_at() + boost::posix_time::seconds(interval));
        timer->async_wait(boost::bind(&PeriodicTask::execute,this));
    }

private:
     std::shared_ptr<boost::asio::io_service> ioService;
     std::shared_ptr<boost::asio::deadline_timer> timer;
     std::shared_ptr<std::function<void()>> task;
     int interval;
};

class PeriodicScheduler
{
public:
    void run()
    {
        for each (auto task in tasks)
        {
            task.execute();
        }
        io_service.run();
    }
    void  addTask(std::function<void()> task, int interval)
    {
        tasks.push_back(PeriodicTask(&io_service, interval, task)); …