Skip to content
[Jenkins]Jenkins
log in

Valgrind Error Details

back to process details
back to processes overview
Executable/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
PID26354
PPID16382
Unique ID0x4d1
Text12 bytes in 1 blocks are still reachable in loss record 1,232 of 4,624
Auxiliary
Suppression{
   <insert_a_suppression_name_here>
   Memcheck:Leak
   match-leak-kinds: reachable
   fun:malloc
   fun:PXAllocate
   fun:PXAllocateMeshElement
   fun:PXTriFixHangingNode
   fun:PXFixHangingNode2d
   fun:PXTri1EdgeSplit
   fun:PXSplitSubMeshForSampling
   fun:PXLocalSamplingOneElem_Cut.isra.26
   fun:PXLocalSampling
   fun:PXPerformLocalSampling
   fun:PXAdaptHPDirectSingleStep
   fun:PXAdaptHPDirectSingleStepWrapper
   fun:PXSolveUnsteadyDualProblem
   fun:PXSolveDual
   fun:PXPSequencing
   fun:main
}

Stacktrace

Object/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so
Functionmalloc
File/Line
CodeSource code not available

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXAllocate
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Fundamentals/PXMemory.c:99
Code
089 
090 
091   tot = n*size;
092   
093   if (likely(tot)){
094     if (unlikely(n<0)){
095       printf("Error, requesting allocation of negative memory size.\n"); fflush(stdout);
096       *po = NULL;
097       return PXError(PX_MEMORY_ERROR);
098     }
099     else if ( unlikely(( _po = (char *)malloc(tot)) == NULL) ){
100       *po = NULL;
101       return PXError(PX_MEMORY_ERROR);
102     }
103   }
104   *po = (void *) _po;

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXAllocateMeshElement
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXSubMesh.c:134
Code
0124   Works for all element types.
0125   */
0126   PX_MasterGridElement *MGE = NULL;
0127   MGE = Elem->MasterGridElement;
0128 
0129   Elem->face       = NULL;
0130   Elem->vertex     = NULL;
0131   Elem->coordinate = NULL;
0132 
0133   PXErrorReturn(PXAllocate( MGE->nFace, sizeof(int), (void**)&Elem->face));
0134   PXErrorReturn(PXAllocate( MGE->nVertex, sizeof(int), (void**)&Elem->vertex));
0135   PXErrorReturn(PXAllocate( MGE->dim*MGE->nNode, sizeof(PX_REAL), (void**)&Elem->coordinate));
0136 
0137   return PX_NO_ERROR;
0138 }
0139 

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXTriFixHangingNode
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXSubMesh.c:777
Code
0767   ledge0 = mesh->Face[f0].lfaceR; /* face-edge duality in 2d */
0768 
0769   /* create new element */
0770   elem1 = mesh->nElement;
0771   mesh->nElement++;
0772   PXErrorReturn(PXReAllocate( mesh->nElement, sizeof(PX_MeshElement), (void**)&mesh->Element ));
0773   Elem0 = mesh->Element + elem0;
0774   MGE = Elem0->MasterGridElement;
0775   Elem1 = mesh->Element + elem1;
0776   Elem1->MasterGridElement = MGE;
0777   PXErrorReturn(PXAllocateMeshElement(Elem1));
0778 
0779   /* update vertex */
0780   memcpy(Elem1->vertex, Elem0->vertex, MGE->nVertex*sizeof(int));
0781   Elem0->vertex[vup0[ledge0]] = v0;
0782   Elem1->vertex[vup1[ledge0]] = v0;

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXFixHangingNode2d
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXSubMesh.c:1049
Code
1039   elem = mesh->Face[f0].elemR;
1040   Elem = mesh->Element +elem;
1041 
1042   if (elem!=mesh->Face[f1].elemR) {
1043     printf("Faces %d and %d need to have same right element, resp. (%d,%d).\n",f0,f1,elem,mesh->Face[f1].elemR);
1044     return PXError(PX_GRID_ERROR);
1045   }
1046 
1047   /* Remember we are in 2d so checking nVertex is ok */
1048   if (Elem->MasterGridElement->nVertex==3)
1049     PXErrorReturn(PXTriFixHangingNode(mesh,f1,f0,vertex,SplitMap));
1050   else if (Elem->MasterGridElement->nVertex==4)
1051     PXErrorReturn(PXQuadFixHangingNode(mesh,f0,f1,vertex,SplitMap));
1052   else {
1053     printf("unknown master element type with %d vertices\n",Elem->MasterGridElement->nVertex);
1054     return PXError(PX_GRID_ERROR);

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXTri1EdgeSplit
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXSubMesh.c:1212
Code
1202 
1203     SplitMap->sample[selem1] = PXE_Sample_EdgeSplit;
1204     SplitMap->isplit[selem1] = 1;
1205     SplitMap->info[selem1]   = ledge0;
1206 
1207     SplitMap->nelem += 2;
1208   }
1209 
1210   /* Fix hanging nodes */
1211   if (mesh->Face[Elem0->face[ledge0]].elemR != -1) {
1212       PXErrorReturn(PXFixHangingNode2d(mesh, Elem0->face[ledge0], f3, v3, SplitMap));
1213   }
1214 
1215   return PX_NO_ERROR;
1216 }
1217 

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXSplitSubMeshForSampling
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXSubMesh.c:2669
Code
2659         SplitMap (in/out): mapping from split mesh to original mesh
2660   */
2661 
2662   PX_MasterGridElement *MGE=NULL;
2663 
2664   MGE = mesh->Element[elem].MasterGridElement;
2665 
2666   if (MGE->dim==2 && MGE->BasisShape==PXE_SimplexShape) {
2667     /* Triangles */
2668     if (type==PXE_Sample_EdgeSplit)
2669       PXErrorReturn(PXTri1EdgeSplit(mesh,elem,info,SplitMap));
2670     else if (type==PXE_Sample_UniformSplit)
2671       PXErrorReturn(PXTri3EdgeSplit(mesh,elem,SplitMap));
2672     else
2673       return PXError(PX_BAD_INPUT);
2674   }

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXLocalSamplingOneElem_Cut.isra.26
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:4305
Code
4295 
4296     /* Initialize AttachSetSplit */
4297     PXErrorReturn(PXInitAttachSet(AttachSetSplit));
4298 
4299     /* Create splitmesh */
4300     PXErrorReturn(PXCreateMesh(&meshsplit));
4301     PXErrorReturn(PXCopyMesh(meshsub,meshsplit));
4302 
4303     /* Split the mesh */
4304     SplitMap->nelem = 0;
4305     PXErrorReturn(PXSplitSubMeshForSampling(meshsplit,0,SamplingData->type[iSample],SamplingData->info[iSample],SplitMap));
4306 
4307     /* Turn the split mesh to a full mesh format (i.e. no -1 faces) */
4308     PXErrorReturn(PXTurnSubMeshToFullMesh(meshsplit));
4309 
4310     /* Convert splitmesh to splitgrid */

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXLocalSampling
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:4584
Code
4574     PXErrorReturn(PXDetermineCutSubMesh(meshsub, Sub2FullMap, CutFlag, NullFlag,&submeshCutFlag));
4575 
4576     /* Do the samping from the sub mesh */
4577     if(submeshCutFlag == PXE_False){
4578       PXErrorReturn(PXLocalSamplingOneElem_NonCut(pxa, UnsteadyIndex, bgAttachSet,
4579                                                   mesh, elem, meshsub,
4580                                                   Sub2FullMap, Mesh2GridMap,
4581                                                   ElemError, LocTime));
4582     }
4583     else{
4584       PXErrorReturn(PXLocalSamplingOneElem_Cut(pxa, UnsteadyIndex, AttachSet,
4585                                                mesh, elem, meshsub,
4586                                                Sub2FullMap, Mesh2GridMap,
4587                                                ElemError, LocTime));
4588     }
4589 

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXPerformLocalSampling
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:4665
Code
4655   /* Get cut flag*/
4656   PXErrorReturn(PXGetCutFlag(pxa->pg, &CutFlag));
4657 
4658   /* Copy current state */
4659   if(CutFlag == PXE_False)
4660     PXErrorReturn(PXCopyCurrentSample(pxa,meshback,AttachSet,ElemError));
4661   else
4662     PXErrorReturn(PXCopyCurrentSample(pxa,meshback,AttachSet->bgAttachSet,ElemError));
4663 
4664   /* Local sampling */
4665   PXErrorReturn(PXLocalSampling(pxa,UnsteadyIndex,meshback,Mesh2GridMap,AttachSet,ElemError));
4666 
4667   /* Reset parameters */
4668   PXErrorReturn(PXSetKeyValue(pxa->Parameter,"Verbosity",VerbosityStr));
4669   PXErrorReturn(PXSetKeyValue(pxa->Parameter,"Preconditioner",PCStr));
4670   PXErrorReturn(PXSetKeyValue(pxa->Parameter,"LineSearchFlag",LineSearchStr));

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXAdaptHPDirectSingleStep
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:7778
Code
7768   if(CutFlag == PXE_False)
7769     PXErrorReturn(PXCopyAttachSetToMesh(Mesh2GridMap,AttachSet));
7770   else //for cut cell, mesh2gridmap stores mapping for background mesh
7771     PXErrorReturn(PXCopyAttachSetToMesh(Mesh2GridMap,AttachSet->bgAttachSet));
7772 
7773   /* perform local sampling */
7774 #ifdef PX_TIMING
7775   PXBarrier();
7776   c0 = PXclock();
7777 #endif
7778   PXErrorReturn(PXPerformLocalSampling(pxa,UnsteadyIndex,meshback,Mesh2GridMap,AttachSet,ElemError));
7779 #ifdef PX_TIMING
7780   PXBarrier();
7781   c1 = PXclock();
7782   PXPrintf("Time : (LocalSolve) = %f\n", c1-c0 );
7783 #endif

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXAdaptHPDirectSingleStepWrapper
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:7869
Code
7859   else {
7860     pgmesh = pg->pgback;
7861     if (pgmesh == NULL) PXErrorReturn(PX_BAD_INPUT);
7862   }
7863   PXErrorReturn(PXConvertGrid2Mesh(pgmesh,meshback,Mesh2GridMap));
7864 
7865   /* Initialize elemerror */
7866   PXErrorReturn(PXAllocateElementError(meshback,ElemError));
7867 
7868   /* Fill element error for this single step */
7869   PXErrorReturn( PXAdaptHPDirectSingleStep( pxa, UnsteadyIndex,
7870                                             meshback, Mesh2GridMap, ElemError, NULL,
7871                                             pErrorEstSum, pErrorEstAbsSum ) );
7872 
7873   /* Retrieve error and metric GRE attachments */
7874   PXErrorReturn( PXAttachSearch(pgmesh,"ElemError0",NULL,(void *)&ElemError0) );

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXSolveUnsteadyDualProblem
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXSolver.c:10865
Code
10855                                                               &ErrorEstSum, &ErrorEstAbsSum) );
10856 
10857       }
10858       else
10859       {
10860 
10861 #ifdef PX_TIMING
10862         c0 = PXclock();
10863 #endif
10864         /* Build grid and fill ElemError structure */
10865         PXErrorReturn( PXAdaptHPDirectSingleStepWrapper(pxa, currentIndex,
10866                                                         &ErrorEstSum, &ErrorEstAbsSum) );
10867 #ifdef PX_TIMING
10868         c1 = PXclock();
10869         PXPrintf("Time : (DualSolve(P+1andLocSolve)) = %f\n", c1-c0 );
10870 #endif

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXSolveDual
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXRunSolver.c:529
Code
0519   PXErrorReturn( PXGetKeyValueInt( pxa->Parameter, "AdaptIter", &AdaptIter ) );
0520 
0521   /*--------------------*/
0522   /* Solve Dual Problem */
0523   /*--------------------*/
0524 
0525   PXPrintf("\n*************\n");
0526   PXPrintf(  " Dual Solver \n");
0527   PXPrintf(  "*************\n");
0528 
0529   PXErrorReturn( PXSolveUnsteadyDualProblem(pxa, &AdaptFlag, &ConvergedFlag) );
0530 
0531   /*-------------------*/
0532   /* Write Output File */
0533   /*-------------------*/
0534 

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXPSequencing
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXRunSolver.c:710
Code
0700       if ( iSolOrder == SolOrder ){
0701   iAdaptFlag = AdaptFlag;
0702       } else {
0703   iAdaptFlag = PXE_False;
0704       }
0705 
0706 #ifdef PX_TIMING
0707     PXBarrier();
0708     c0 = PXclock();
0709 #endif
0710       PXErrorReturn( PXSolveDual(pxa, iAdaptFlag, aiter, &ConvergedFlag, &iSolOrder) );
0711 #ifdef PX_TIMING
0712     PXBarrier();
0713     c1 = PXclock();
0714     PXPrintf("Time : (DualSolveTotal) = %f\n", c1-c0 );
0715 #endif

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
Functionmain
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXRunSolver.c:999
Code
0989     PXErrorReturn( PXInitializeAdaptIter( pxa, aiter ) );
0990     //pg = pxa->pg;
0991 
0992 #ifdef PX_TIMING
0993     PXBarrier();
0994     c2=PXclock();
0995     PXPrintf("Time : (InitializeAdaptIter) = %f\n", c2 - c1 );
0996 #endif
0997 
0998     /* Perform PSequencing */
0999     PXErrorReturn( PXPSequencing( pxa, AdaptFlag, aiter, &ConvergedFlag ) );
1000 
1001 #ifdef PX_TIMING
1002     PXBarrier();
1003     c1=PXclock();
1004     PXPrintf("Time : (PXPSequencing) = %f\n",  c1 - c2);