Status

Changes

Console Output

View Build Information

Git Build Data

Console Output (parsed)

Valgrind Result

Embeddable Build Status

Previous Build

Next Build

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
PID	26354
PPID	16382
Unique ID	0x114e
Text	2,576 bytes in 1 blocks are still reachable in loss record 4,429 of 4,624
Auxiliary
Suppression	{ <insert_a_suppression_name_here> Memcheck:Leak match-leak-kinds: reachable fun:malloc fun:PXAllocate fun:PXCreateLocMeshAttachRealElem fun:PXCopyLocAttachGREToRealElem fun:PXCopyAttachSetToMesh fun:PXAdaptHPDirectSingleStep fun:PXAdaptHPDirectSingleStepWrapper fun:PXSolveUnsteadyDualProblem fun:PXSolveDual fun:PXPSequencing fun:main }

Stacktrace

Object	/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so
Function	malloc
File/Line
Code	Source code not available

Object /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec

Function PXAllocate

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

Function PXCreateLocMeshAttachRealElem

File/Line /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXMeshAttachment.c:230

Code


220       PXErrorReturn(PXOrder2nbf(order[elem],&nbf));

221       RealElem->order[elem] = order[elem];

222     }

223     RealElem->rank[elem] = nbf*stateRank;

224     totalRank += RealElem->rank[elem];

225   }

226   RealElem->totalRank = totalRank;

227 

228   /* allocate value */

229   RealElem->value = NULL;


230   PXErrorReturn(PXAllocate(nElem,sizeof(PX_REAL*),(void**)&RealElem->value));


231   RealElem->value[0] = NULL;

232   PXErrorReturn(PXAllocate(totalRank,sizeof(PX_REAL),(void**)&RealElem->value[0]));

233   RealElem->valuestart = RealElem->value[0];

234   

235   /* set pointers for value */

Object /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec

Function PXCopyLocAttachGREToRealElem

File/Line /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/Grid/PXMeshAttachment.c:304

Code


294 

295   /* fill order array */

296   nElement = Mesh2GridMap->nElement;

297   PXErrorReturn(PXAllocate(nElement,sizeof(enum PXE_SolutionOrder),(void**)&order));

298   for (elem = 0; elem < nElement; elem++) {

299     egrp2 = Mesh2GridMap->egrpmap[elem];

300     order[elem] = GRE->order[egrp2];

301   }

302   

303   /* create attachment */


304   PXErrorReturn(PXCreateLocMeshAttachRealElem(nElement, PXE_False, order, GRE->StateRank, &RealElem) );


305   *pRealElem = RealElem;

306 

307   /* copy data */

308   for (elem = 0; elem < Mesh2GridMap->nElement; elem++) {

309     egrp2 = Mesh2GridMap->egrpmap[elem];

Object /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec

Function PXCopyAttachSetToMesh

File/Line /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:2405

Code


2395       for ( iStage=0; iStage<maxNStage ; iStage++ )

2396   if ( AttachSet->TSNextStageAdjState[iState] != NULL && AttachSet->TSNextStageAdjState[iState][iStage] != NULL ){

2397     PXErrorReturn(PXCopyLocAttachGREToRealElem( Mesh2GridMap,

2398                   AttachSet->TSNextStageAdjState[iState][iStage][0],

2399                   &(AttachSet->TSNextStageAdjStateMesh[iState][iStage]) ));

2400   } else {

2401     AttachSet->TSNextStageAdjStateMesh[iState][iStage] = NULL;

2402   }

2403   }

2404   if (AttachSet->ErrorIndicator != NULL) {


2405     PXErrorReturn(PXCopyLocAttachGREToRealElem(Mesh2GridMap,


2406                  AttachSet->ErrorIndicator,

2407                  &AttachSet->ErrorIndicatorMesh));

2408   }

2409   if (AttachSet->ErrEstDWPR != NULL) {

2410     PXErrorReturn(PXCopyLocAttachGREToRealElem(Mesh2GridMap,

Object /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec

Function PXAdaptHPDirectSingleStep

File/Line /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/src/PXHPAdaptDirect.c:7771

Code


7761 #ifdef PX_TIMING

7762   PXBarrier();

7763   c1 = PXclock();

7764   PXPrintf("Time : (DualSolve(P+1)) = %f\n", c1-c0 );

7765 #endif

7766 

7767   /* transfer attachments set to mesh */

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

Object /home1/jenkins/workspace/ProjectX_Weekly/PX_ARC/relwithdebinfo_gnu/buildnode/reynolds/platforms/relwithdebinfo_gnu/bin/ProjectXExec

Function PXAdaptHPDirectSingleStepWrapper

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

Function PXSolveUnsteadyDualProblem

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

Function PXSolveDual

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

Function PXPSequencing

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

Function main

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