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 ID0x107b
Text1,024 bytes in 1 blocks are still reachable in loss record 4,218 of 4,624
Auxiliary
Suppression{
   <insert_a_suppression_name_here>
   Memcheck:Leak
   match-leak-kinds: reachable
   fun:malloc
   fun:PXAllocate
   fun:GetNodeEdge2ZeroD.isra.20
   fun:BuildZeroD
   fun:PXIntersect2DCutGrid
   fun:PXBuildCutGrid2D
   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
FunctionGetNodeEdge2ZeroD.isra.20
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXIntersect2d.c:3773
Code
03763       TwoD->Node2ZeroD[node][TwoD->Node2nZeroD[node]] = zerod;
03764       TwoD->Node2nZeroD[node]++;
03765     }
03766   }
03767 
03768   /****************************************************************************************/
03769   /*                                    Knot To ZeroD                                     */
03770   /****************************************************************************************/
03771 
03772   /* allocate memory for pointer from spline knots to ZeroD */
03773   PXErrorReturn( PXAllocate( pgsurf->nNode, sizeof(int *), (void **)&(TwoD->Knot2ZeroD) ) );
03774   for (knot=0; knot<pgsurf->nNode; knot++){
03775     TwoD->Knot2ZeroD[knot] = NULL;
03776     PXErrorReturn( PXAllocate( TwoD->Knot2nZeroD[knot], sizeof(int), (void **)&(TwoD->Knot2ZeroD[knot]) ) );
03777   }
03778 

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionBuildZeroD
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXIntersect2d.c:4114
Code
04104   /****************************************************************************************/
04105 
04106   PXErrorReturn( CleanKnotNodeIntersection(pg, TwoD) );
04107 
04108   PXErrorReturn( CleanKnotEdgeIntersection(pg, TwoD) );
04109 
04110   // merge all knots at a multi-spline intersection to a single node by marking the others are 'Duplicates'
04111   PXErrorReturn( CleanKnotSplineIntersection(pg, TwoD) );
04112 
04113   /* we also want to be able to go from each cut edge to the zero d points on it */
04114   PXErrorReturn( GetNodeEdge2ZeroD(pg, TwoD) );
04115 
04116   /* allocate memory for CutZeroD2nOneD */
04117   PXErrorReturn( PXAllocate( TwoD->nZeroD, sizeof(int), (void **)&(TwoD->CutZeroD2nOneD) ) );
04118   for (zerod=0; zerod<TwoD->nZeroD; zerod++){
04119     TwoD->CutZeroD2nOneD[zerod] = 0;

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXIntersect2DCutGrid
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXIntersect2d.c:13369
Code
13359   if(pg->pgback->Node == NULL)
13360     PXErrorReturn( PXCreateNodeStructure(pg->pgback) );
13361 
13362   /* create TwoD intersect structure */
13363   PXErrorReturn( CreateTwoDIntersectStructure(pg,&TwoD) );
13364 
13365   /* Build all the zero d points */
13366   if (PrintCutGridInfoToScreen==PXE_True){
13367     printf("Building ZeroD . . .");  fflush(stdout);
13368   }
13369   PXErrorReturn( BuildZeroD(pg, TwoD, PrintCutGridInfoToScreen) );
13370   if (PrintCutGridInfoToScreen==PXE_True){
13371     printf("Done \n"); fflush(stdout);
13372   }
13373   /* build all the one d edges */
13374   if (PrintCutGridInfoToScreen==PXE_True){

Object/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec
FunctionPXBuildCutGrid2D
File/Line/home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXCutQuad.c:6717
Code
6707   //PX_REAL *xref = NULL;
6708   //PX_REAL xglobal[3];
6709 
6710   /* seed the random number generator */
6711   PXErrorReturn( PXRandNumGen(2, &rand_num, PXE_True) );
6712 //  PXErrorReturn( PXRandNumGen(0, &rand_num, PXE_False) );
6713 /*   printf("rand_num = %.15e\n",rand_num); */
6714 
6715 
6716   /* intersect our grid and generate our TwoD intersection Structure */
6717   PXErrorReturn( PXIntersect2DCutGrid(pg, &TwoD, MoveToCanonicalFlag, RemoveDoubleSplineFace, PrintCutGridInfoToScreen) );
6718   pg->TwoD = TwoD;
6719 
6720   /* generate the quadrature rules for all the cut elements and faces */
6721 
6722   PXErrorReturn( Generate2DCutQuadRules(pg, TwoD, FaceQuadOrder, ElemQuadOrder, TotalDegreeFlag) );

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:4334
Code
4324       /* Also, just copy the whole spline information, might cause a speed issue*/
4325       PXErrorReturn(PXTransferSplines(pg->pgback, pgbacksplit));
4326 
4327       /* Modify pgback to add extra embedded face groups */
4328       /* This needs to be done, because JM's intersection codes assumed
4329    pgback->nFaceGroup = pgsurf->nElementGroup
4330    This is also assumed for spline attachment*/
4331       //PXErrorReturn( PXModifypgbackToMatchExistingpgsurf(pgsplitcut->pgback, pgsplitcut->pgsurf) );
4332 
4333       /* Cut */
4334       ierr =  PXBuildCutGrid2D(pgsplit, NULL, MoveToCanonicalFlag, CanonicalBasisFlag, RemoveDoubleSplineFace, OneDQuadOrder, TwoDQuadOrder, TotalDegreeFlag, PrintCutGridInfoToScreen);
4335       CutSuccess = (ierr == PX_NO_ERROR) ? PXE_True : PXE_False;
4336     }
4337     else{
4338       PXErrorReturn(PX_BAD_INPUT);
4339     }

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);