提高C+的性能+； 我试图在C++中创建线程。我当然觉得在for循环中创建线程并不意味着并行。但我想将下面的逻辑代码段并行化 for(int i = 0; i < 100000; i++) // for each instance in the dataset { for(int j = 0; j < 100000; j++) // target each other instance { if(i == j) continue; float distance = 0; for(int k = 0; k < 2000; k++) { float a = dataset->get_instance(i)->get(k)->operator float(); float b = dataset->get_instance(j)->get(k)->operator float(); float diff = a - b distance += diff * diff; } distance = distance + 10; } } for（int i=0；i操作符float（）； float b=dataset->get_实例（j）->get（k）->操作符float（）； 浮差=a-b 距离+=diff*diff； } 距离=距离+10； } }

上述代码段中是否存在并行性的可能性？或者任何人都可以提供一些代码示例来理解线程的类似并行化。

如果所显示的函数都没有副作用，您只需在

i

循环的每次迭代中运行一个线程，您可以创建N个线程并将外部

i

循环的迭代次数除以每个线程，或者您可以使用

std:：async

：

struct ShortestDistance {
    float distance;
    int distClass;
};

ShortestDistance inner_loop(const Dataset* dataset, int i)
{
    ShortestDistance dist { MAX_FLT, 0 };

    for(int j = 0; j < dataset->num_instances(); j++) // target each other instance
    {
        if(i == j) continue;

        float distance = 0;

        for(int k = 0; k < dataset->num_attributes() - 1; k++) // compute the distance between the two instances
        {
            float a = dataset->get_instance(i)->get(k)->operator float();
            float b = dataset->get_instance(j)->get(k)->operator float();
            float diff = a - b
            distance += diff * diff;
        }

        distance = sqrt(distance);
        if (distance < dist.distance) {
            dist.distance = distance;
            dist.distClass = dataset->get_instance(j)->get(dataset->num_attributes() - 1)->operator int32();
        }
    }

    return dist;
}

void outer_loop(const Dataset* dataset)
{
    std::vector<std::future<ShortestDistance>> vec;
    for(int i = 0; i < dataset->num_instances(); i++) // for each instance in the dataset
    {    
        vec[i] = std::async(inner_loop, dataset, i);
    }

    DistanceResult overallResult { FLT_MAX, 0 };
    for (auto&& fut : vec)
    {
        DistanceResult threadResult = fut.get();
        if (threadResult.distance < overallResult.distance)
            overallResult = threadResult);
    }
}

struct ShortestDistance{
浮动距离；
int类；
};
最短距离内循环（常量数据集*数据集，整数i）
{
最短距离距离{MAX_FLT，0}；
对于（int j=0；jnum_instances（）；j++）//以每个实例为目标
{
如果（i==j）继续；
浮动距离=0；
对于（int k=0；knum_attributes（）-1；k++）//计算两个实例之间的距离
{
float a=dataset->get_实例（i）->get（k）->操作符float（）；
float b=dataset->get_实例（j）->get（k）->操作符float（）；
浮差=a-b
距离+=diff*diff；
}
距离=sqrt（距离）；
if（距离<距离）{
距离=距离；
dist.distClass=dataset->get_实例（j）->get（dataset->num_属性（）-1）->运算符int32（）；
}
}
返回距离；
}
无效外部循环（常量数据集*数据集）
{
std:：vec；
对于（int i=0；inum_instances（）；i++）//数据集中的每个实例
{    
vec[i]=std:：async（内部循环，数据集，i）；
}
距离结果总体结果{FLT_MAX，0}；
用于（自动和未来：vec）
{
DistanceResult threadResult=fut.get（）；
if（threadResult.distance<总体结果.distance）
总体结果=线程结果）；
}
}

首先，您需要了解您有多少硬件核心。然后，您需要以最有效的方式度量和划分工作。所以，基本上，尝试并失败，直到成功。这段代码似乎没有做任何事情<代码>距离是在

for（j）

循环中声明的，因此外部值未知。@kfsone:我已经更新了外部距离的用法，请您提供任何指针或给我任何代码逻辑作为结果。您需要先让我们知道您想要并行化什么。您正在尝试计算两点之间的最短距离，这不需要并行化。

距离

仍然只在

j

循环中已知，因此您在

i

循环末尾添加的代码无效，而最短距离也有同样的问题。编译器可以轻松省略整个函数：