Question

我是多线程新手，我会尽量保持清醒。我正在使用标准库std :: thread在C ++中创建多线程算法。我的代码正在编译并运行，没有错误。我把代码放在两个线程上。两个线程创建的ID不同于主要的（我使用getid（）和Visual Studio中的线程窗口检查）。问题是我没有及时获得，并且我的CPU利用率是相同的，所以看起来它们运行在同一个CPU线程上。

这是否意味着线程不会自动意味着在不同的CPU内核和线程上运行以获得时间？

我是否需要添加指令或将此代码与多线程库结合使用？或者只是一个错误？任何帮助都会非常感谢，谢谢

double internalenergy=0;
unsigned int NUM_THREADS = std::thread::hardware_concurrency();
NUM_THREADS=2;
 vtkIdType num_cells = referencemesh_->GetNumberOfCells();
 int start_node[8];
 int end_node[8];
 int intervalle=num_cells/NUM_THREADS;
for( unsigned int i=0; i < NUM_THREADS; ++i )
{
    start_node[i] = (float)num_cells*i/NUM_THREADS;       
    end_node[i]   = (float)num_cells*(i+1)/NUM_THREADS;
}
const double* pointeurpara;
pointeurpara=&params(0);

double value1=0;
double* P_value1;
P_value1=&value1;

double value2=0;
double* P_value2;
P_value2=&value2;

std::thread first(threadinternalenergy,activemesh,referencemesh_,start_node[0],P_value1,pointeurpara);
std::thread second (threadinternalenergy,activemesh,referencemesh_,start_node[1],P_value2,pointeurpara);
first.join(); 
second.join();
double displacementneighpoint=*P_value1+*P_value2;

以下是threadinternalenergy的源代码

void threadinternalenergy(vtkSmartPointer<vtkPolyData>, 
activemesh,vtkSmartPointer<vtkPolyData> referencemesh,int startcell,double* 
displacementneighpoint,const double* p) 
{
 unsigned long processnumber;
 processnumber=GetCurrentProcessorNumber();
 cout<<"process "<<processnumber<<endl;

unsigned int NUM_THREADS = std::thread::hardware_concurrency();
NUM_THREADS=2;
vtkIdType num_cells = referencemesh->GetNumberOfCells();
int intervalle=num_cells/NUM_THREADS;
int endcell=startcell+intervalle;
//cout<<"start cell "<<startcell<<endl;
//cout<<"end cell "<<endcell<<endl;
int numcell_th=startcell-endcell;

 vtkSmartPointer<vtkEdgeTable> vtk_edge_tableT = 
vtkSmartPointer<vtkEdgeTable>::New();
  vtk_edge_tableT->InitEdgeInsertion(numcell_th*3);

  // Initialize edge table
  vtkSmartPointer<vtkEdgeTable> vtk_edge_table = 
vtkSmartPointer<vtkEdgeTable>::New();
  vtk_edge_table->InitEdgeInsertion( numcell_th*3 );

  cout<<"start cell "<<startcell<<endl;

 for( vtkIdType i=startcell; i < endcell; ++i )
  {   
    vtkCell* cell = referencemesh->GetCell( i );
 // cout<<"cell"<<endl;
    // Traverse edges in cell -- assuming a linear cell (line, triangle; NOT 
  rectangle)
    for( vtkIdType j=0; j < cell->GetNumberOfEdges(); ++j )
    {
        // cout<<"edge"<<endl;
      vtkCell* edge = cell->GetEdge( j );

      vtkIdType pt0 = edge->GetPointId(0);
      vtkIdType pt1 = edge->GetPointId(1);


    //consider edge if a displacement has been point by at least one point
        //if(params(pt0)!=0 || params(pt1)!=0){


          if( vtk_edge_table->IsEdge( pt0, pt1 ) == -1 ){     // If this edge 
     is not in the edge table
                vtk_edge_table->InsertEdge( pt0, pt1 );
              //acess point coordinate
             // vtkPoints* listpoints=edge->GetPoints();
              double p0 [3];
              double p1 [3];
              referencemesh->GetPoint(pt0,p0);
              referencemesh->GetPoint(pt1,p1);


                //2e Mesh (Mesh transform)
                 double p0T [3];
              double p1T [3];
              activemesh->GetPoint(pt0,p0T);
              activemesh->GetPoint(pt1,p1T);


                    // If this edge is not in the edge table
                vtk_edge_tableT->InsertEdge( pt0, pt1 );


                //find displacement difference for 2 points sharing an edge
                double squaredDistancep0 = 
                vtkMath::Distance2BetweenPoints(p0, p0T);
                double distancep0 = sqrt(squaredDistancep0);
                double squaredDistancep1 = 
                vtkMath::Distance2BetweenPoints(p1, p1T);
                double distancep1 = sqrt(squaredDistancep1);
                double difference = abs(distancep0 - distancep1);
                difference=((difference+1)*(difference+1))-1;
                //if(difference>0.25){
                    //cout<<"grosse difference "<<difference<<endl;
                //}
                *displacementneighpoint+=difference;
                //displacementpointneigh.push_back(difference);



             }

        //}

    } 
  }
 cout<<"Fin du thread "<<endl;
 }

Answer 1

线程可能在不同的核心上运行。这并不一定意味着程序会更快。它可能比一个线程运行得慢得多。线程必须同时做足够的工作来证明线程创建和同步的开销。有很多陷阱。一个可能的问题是线程经常共享（或“错误共享”）内存。

是的，线程背后的一个主要思想是“做并发”。但这可以通过只有一个核心的CPU来完成！或者它可能无法很好地处理大量内核。

我写了一个用于控制处理计算机晶圆的机器人的系统。它运行在具有一个核心的CPU上，但它强烈依赖于并发性。并发性源于使CPU以外的设备与其同时运行，例如：伺服放大器和网卡。一个高优先级线程专门用于通过网络管理伺服。其他线程使用松弛时间来计划轨迹，与主机通信等等......当伺服控制线程因为网卡有来自伺服的响应而醒来时，它立即接管了CPU并完成了它的工作。的事情。

今年在cppCon上发表了题为“当一微秒是永恒的”时的一次谈话。这家伙设计了一个偷偷摸摸的股票交易系统。对他来说最重要的是他能够以多快的速度处理将他连接到市场的网络。为了获得他所需的吞吐量，他使用了一个禁用三个核心的4核机器。为什么？因为他找不到足够好的1核机器。

我还编写了一个使用多线程在多核计算机上进行计算的类。它悲惨地失败了。有些任务不适合分而治之。

C ++多线程算法创建在同一CPU线程上运行的多个线程

1 个答案: