Attachment #102226 for bug #194081

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





// Aggregated
void 
CProfEnv::AddNewStackEntry(TId threadId, TId methodId, U64 enterTime, U64 uiCpuNanos)
{
    CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();
    if (stack == 0) {

        lockAggObject->Leave();
    }
    stack->lockThreadObject->Enter();
    stack->AddStackEntry(methodId, enterTime, uiCpuNanos);
    stack->lockThreadObject->Leave();
}

// Aggregated
int 
CProfEnv::FinalizeStackEntry(TId threadId, TId methodId, U64 exitTime, U64 uiCpuNanos)
{
    int result;
    CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();
    if (stack == 0) {
        stack = new CStackHead(ec_env, threadId);

        lockAggObject->Leave();
    }
    stack->lockThreadObject->Enter();
    if ((result = stack->FinalizeStackEntry(exitTime, uiCpuNanos)) == -1) {
        stack->SetNewRoot(methodId, /*can be attachTime*/0, /*exitTime*/0, /*attachCPUTime*/0, 0/*uiCpuNanos*/);
        // fake stack entry is added
    }
    stack->lockThreadObject->Leave();
    return result;
}

// Aggregated

void CProfEnv::DeleteAggCallGraphData() {
    lockAggObject->Enter();
    if (m_pStackSet != 0) {
        m_pStackSet->ClearAll();
    }
    lockAggObject->Leave();
}





    class CStackEntry {
    public:
        CStackEntry(JPIAgent::EC_Env* ec_env, MPI::TId methodId, CStackEntry* caller, U64 enterTime, U64 uiCpuNanos) {
            m_ec_env = ec_env;
            m_MethodId = methodId;
            m_pCaller = caller;

            m_maxTime = 0;
            m_count = 0;

            m_EnterTime = enterTime;
            m_InvokeTime = 0;
            m_EnterCpuTime = uiCpuNanos;
            m_InvokeCpuTime = 0;

            }
        }

        CStackEntry* AddStackEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
            if (m_pCallSet == 0) {
                m_pCallSet = new CStackEntry(m_ec_env, methodId, this, enterTime, uiCpuNanos);
                return m_pCallSet;
            }
            return m_pCallSet->AddSetEntry(methodId, enterTime, uiCpuNanos);
        }

        CStackEntry* FinalizeStackEntry(U64 exitTime, U64 uiCpuNanos) {
            m_count++;
            U64 cumulativeTime = exitTime - m_EnterTime;
            U64 baseTime = cumulativeTime - m_InvokeTime;
            m_baseTime += baseTime;
            U64 cumulativeCpuTime = uiCpuNanos - m_EnterCpuTime;

                m_minTime = baseTime;
            }
            isActive = false;
            // TODO
            return m_pCaller;
        }

        CStackEntry* AddSetEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
            if (m_MethodId == methodId) {
                m_EnterTime = enterTime;
                m_InvokeTime = 0;
                m_EnterCpuTime = uiCpuNanos;
                m_InvokeCpuTime = 0;

                return this;
            }
            if (m_pNext != 0) {
                return m_pNext->AddSetEntry(methodId, enterTime, uiCpuNanos);
            }
            m_pNext = new CStackEntry(m_ec_env, methodId, m_pCaller, enterTime, uiCpuNanos);
            return m_pNext;
        }


        }

        // Partial memory cleaning in cg, counters reset
        void ClearInactive() {
            if (!isActive) {
                m_baseTime = 0;
                m_baseCPUTime = 0;

                m_maxTime = 0;
                m_count = 0;
                if (m_pCallSet != 0) {
                    m_pCallSet->ClearInactive();
                    delete m_pCallSet;
                    m_pCallSet = 0;
                }
            } else {
                if (m_pCallSet != 0) {
                    m_pCallSet->ClearInactive();
                }           
            }
            if (m_pNext != 0) {
                m_pNext->ClearInactive();
                delete m_pNext;
                m_pNext = 0;
            }
        }

        void ClearAll() {
            if (m_pCallSet != 0) {
                m_pCallSet->ClearAll();
                delete m_pCallSet;
                m_pCallSet = 0;
            }           
            if (m_pNext != 0) {
                m_pNext->ClearAll();
                delete m_pNext;
                m_pNext = 0;
            }
        }


            }
        }

        void SetCallSet(CStackEntry* callee) {
            m_pCallSet = callee;
        }

    private:
        JPIAgent::EC_Env* m_ec_env;
        CStackEntry* m_pCaller;

            m_pNext = next;
        }

        void AddStackEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
            if (m_pFirstStackEntry == 0) {
                m_pFirstStackEntry = m_pCurrentStackEntry = new CStackEntry(m_ec_env, methodId, 0, enterTime, uiCpuNanos);
                return;
            }
            if (m_pCurrentStackEntry == 0) {
                m_pCurrentStackEntry = m_pFirstStackEntry->AddSetEntry(methodId, enterTime, uiCpuNanos);
                return;
            }
            m_pCurrentStackEntry = m_pCurrentStackEntry->AddStackEntry(methodId, enterTime, uiCpuNanos);
        }

        int FinalizeStackEntry(U64 enterTime, U64 uiCpuNanos) {
//            LOG_ASSERT(m_pCurrentStackEntry != 0); TODO check it
            if (m_pCurrentStackEntry != 0) {
                m_pCurrentStackEntry = m_pCurrentStackEntry->FinalizeStackEntry(enterTime, uiCpuNanos);
                return 0;
            }
            //such situation have to be fixed by adding new parent stack entry
            return -1;
        }

        void PrintAggCallGraph() {

            if (m_pFirstStackEntry != 0) {
                m_pFirstStackEntry->PrintStack(m_ThreadId);
                if (m_ec_env->isStackMemoryFree()) {
                    m_pFirstStackEntry->ClearInactive();
                }
            }
            lockThreadObject->Leave();
        }

        void ClearInactive() {
            if (m_pFirstStackEntry) {
                m_pFirstStackEntry->ClearInactive();
            }
        }

        void ClearAll() {
            if (m_pFirstStackEntry) {
                m_pFirstStackEntry->ClearAll();
                m_pFirstStackEntry = 0;
            }
        }


        void SetNewRoot(MPI::TId methodId, U64 enterTime, U64 exitTime, U64 enterCpuNanos, U64 uiCpuNanos) {
            //ASSERT (m_pCurrentStackEntry == NULL)
            CStackEntry* newFirstStackEntry = new CStackEntry(m_ec_env, methodId, 0, enterTime, enterCpuNanos);
            newFirstStackEntry->FinalizeStackEntry(exitTime, uiCpuNanos);
            newFirstStackEntry->SetCallSet(m_pFirstStackEntry);
            m_pFirstStackEntry = newFirstStackEntry;
            m_pCurrentStackEntry = 0;
        }




        OSA::IThreadSync* lockThreadObject;

    private:

Lines 94-102 Link Here

(-)src-native/src/BaseProf/ProfEnv.h (-2 / +2 lines)
94	//	94	//
95	U64 GetTimeOut(MPI::TId threadId);	95	U64 GetTimeOut(MPI::TId threadId);
96	// Aggregated	96	// Aggregated
97	void AddNewStackEntry(MPI::TId threadId, MPI::TId methodId, U64 uiCpuNanos);	97	void AddNewStackEntry(MPI::TId threadId, MPI::TId methodId, U64 enterTime, U64 uiCpuNanos);
98	// Aggregated	98	// Aggregated
99	void FinalizeStackEntry(MPI::TId threadId, U64 uiCpuNanos);	99	int FinalizeStackEntry(MPI::TId threadId, MPI::TId methodId, U64 exitTime, U64 uiCpuNanos);
100	// Aggregated	100	// Aggregated
101	void PrintAggCallGraph();	101	void PrintAggCallGraph();
102	// Aggregated	102	// Aggregated

Lines 166-173 Link Here

(-)src-native/src/ACCollector/ACCollector.cpp (-1 / +1 lines)
166	if (!isAgentInitialized(cmdBlock->getContextID())) {	166	if (!isAgentInitialized(cmdBlock->getContextID())) {
167	return 0;	167	return 0;
168	}	168	}
169	m_ACC_env->Detach();
170	m_ACC_env->StopTracing();	169	m_ACC_env->StopTracing();
		170	m_ACC_env->Detach();
171	m_isTracing = false;	171	m_isTracing = false;
172	return BaseCollectorImpl::stop(cmdBlock);	172	return BaseCollectorImpl::stop(cmdBlock);
173	}	173	}

Lines 63-69 Link Here

(-)src-native/src/CGProf/MethodEnterEvent.cpp (-1 / +1 lines)
63	m_pProfEnv->ec_env->PrintMethodEntryElement(data.threadId, data.methodId, classInfo.classId, ticket, stackDepth);	63	m_pProfEnv->ec_env->PrintMethodEntryElement(data.threadId, data.methodId, classInfo.classId, ticket, stackDepth);
64	}	64	}
65	} else {	65	} else {
66	m_pProfEnv->AddNewStackEntry(data.threadId, data.methodId, data.uiCpuNanos);	66	m_pProfEnv->AddNewStackEntry(data.threadId, data.methodId, m_pProfEnv->ec_env->GetTime(), data.uiCpuNanos);
67	}	67	}
68	}	68	}
69		69

Lines 63-69 Link Here

(-)src-native/src/CGProf/MethodLeaveEvent.cpp (-1 / +4 lines)
63	m_pProfEnv->ec_env->PrintMethodExitElement(data.threadId, data.methodId, classInfo.classId, ticket, cpuTime);	63	m_pProfEnv->ec_env->PrintMethodExitElement(data.threadId, data.methodId, classInfo.classId, ticket, cpuTime);
64	}	64	}
65	} else {	65	} else {
66	m_pProfEnv->FinalizeStackEntry(data.threadId, data.uiCpuNanos);	66	if (-1 == m_pProfEnv->FinalizeStackEntry(data.threadId, data.methodId, m_pProfEnv->ec_env->GetTime(), data.uiCpuNanos)) {
		67	// Finalize has added fake stack entry without real enter to the method, hence methodID should be checked.
		68	m_pProfEnv->CheckMethodId(data.methodId);
		69	}
67	}	70	}
68	}	71	}
69		72

Lines 260-266 Link Here

(-)src-native/src/JPIAgent/PrintXML.cpp (-1 / +1 lines)
260	CElementBuffer elb;	260	CElementBuffer elb;
261	AppendEmptyEventHeader(&elb, threadId, AG_METHOD_ENTRY_ELEMENT, STRLEN_AG_METHOD_ENTRY_ELEMENT);	261	AppendEmptyEventHeader(&elb, threadId, AG_METHOD_ENTRY_ELEMENT, STRLEN_AG_METHOD_ENTRY_ELEMENT);
262	AppendInteger64Attribute(&elb, STATIC_METHOD_IDREF_ATTRIBUTE, STRLEN_STATIC_METHOD_IDREF_ATTRIBUTE, methodId);	262	AppendInteger64Attribute(&elb, STATIC_METHOD_IDREF_ATTRIBUTE, STRLEN_STATIC_METHOD_IDREF_ATTRIBUTE, methodId);
263	if (numCalls >> 0) {	263	if (numCalls > 0) {
264	AppendLabeledTimestamp(&elb, BASETIME1_ATTRIBUTE, STRLEN_BASETIME1_ATTRIBUTE, baseTime, TRUE);	264	AppendLabeledTimestamp(&elb, BASETIME1_ATTRIBUTE, STRLEN_BASETIME1_ATTRIBUTE, baseTime, TRUE);
265	AppendLabeledTimestamp(&elb, MINTIME_ATTRIBUTE, STRLEN_MINTIME_ATTRIBUTE, minTime, TRUE);	265	AppendLabeledTimestamp(&elb, MINTIME_ATTRIBUTE, STRLEN_MINTIME_ATTRIBUTE, minTime, TRUE);
266	AppendLabeledTimestamp(&elb, MAXTIME_ATTRIBUTE, STRLEN_MAXTIME_ATTRIBUTE, maxTime, TRUE);	266	AppendLabeledTimestamp(&elb, MAXTIME_ATTRIBUTE, STRLEN_MAXTIME_ATTRIBUTE, maxTime, TRUE);

Return to bug 194081

Lines 442-448 Link Here

(-)src-native/src/BaseProf/ProfEnv.cpp (-6 / +11 lines)
442		442
443	// Aggregated	443	// Aggregated
444	void	444	void
445	CProfEnv::AddNewStackEntry(TId threadId, TId methodId, U64 uiCpuNanos)	445	CProfEnv::AddNewStackEntry(TId threadId, TId methodId, U64 enterTime, U64 uiCpuNanos)
446	{	446	{
447	CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();	447	CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();
448	if (stack == 0) {	448	if (stack == 0) {
Lines 454-467 Link Here
454	lockAggObject->Leave();	454	lockAggObject->Leave();
455	}	455	}
456	stack->lockThreadObject->Enter();	456	stack->lockThreadObject->Enter();
457	stack->AddStackEntry(methodId, uiCpuNanos);	457	stack->AddStackEntry(methodId, enterTime, uiCpuNanos);
458	stack->lockThreadObject->Leave();	458	stack->lockThreadObject->Leave();
459	}	459	}
460		460
461	// Aggregated	461	// Aggregated
462	void	462	int
463	CProfEnv::FinalizeStackEntry(TId threadId, U64 uiCpuNanos)	463	CProfEnv::FinalizeStackEntry(TId threadId, TId methodId, U64 exitTime, U64 uiCpuNanos)
464	{	464	{
		465	int result;
465	CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();	466	CStackHead* stack = (CStackHead*)m_pAggStorage->GetValue();
466	if (stack == 0) {	467	if (stack == 0) {
467	stack = new CStackHead(ec_env, threadId);	468	stack = new CStackHead(ec_env, threadId);
Lines 472-479 Link Here
472	lockAggObject->Leave();	473	lockAggObject->Leave();
473	}	474	}
474	stack->lockThreadObject->Enter();	475	stack->lockThreadObject->Enter();
475	stack->FinalizeStackEntry(uiCpuNanos);	476	if ((result = stack->FinalizeStackEntry(exitTime, uiCpuNanos)) == -1) {
		477	stack->SetNewRoot(methodId, /can be attachTime/0, /exitTime/0, /attachCPUTime/0, 0/uiCpuNanos/);
		478	// fake stack entry is added
		479	}
476	stack->lockThreadObject->Leave();	480	stack->lockThreadObject->Leave();
		481	return result;
477	}	482	}
478		483
479	// Aggregated	484	// Aggregated
Lines 490-496 Link Here
490	void CProfEnv::DeleteAggCallGraphData() {	495	void CProfEnv::DeleteAggCallGraphData() {
491	lockAggObject->Enter();	496	lockAggObject->Enter();
492	if (m_pStackSet != 0) {	497	if (m_pStackSet != 0) {
493	m_pStackSet->Clear();	498	m_pStackSet->ClearAll();
494	}	499	}
495	lockAggObject->Leave();	500	lockAggObject->Leave();
496	}	501	}

Lines 127-133 Link Here

(-)src-native/src/BaseProf/Tickets.h (-25 / +66 lines)
127		127
128	class CStackEntry {	128	class CStackEntry {
129	public:	129	public:
130	CStackEntry(JPIAgent::EC_Env* ec_env, MPI::TId methodId, CStackEntry* caller, U64 uiCpuNanos) {	130	CStackEntry(JPIAgent::EC_Env* ec_env, MPI::TId methodId, CStackEntry* caller, U64 enterTime, U64 uiCpuNanos) {
131	m_ec_env = ec_env;	131	m_ec_env = ec_env;
132	m_MethodId = methodId;	132	m_MethodId = methodId;
133	m_pCaller = caller;	133	m_pCaller = caller;
Lines 140-146 Link Here
140	m_maxTime = 0;	140	m_maxTime = 0;
141	m_count = 0;	141	m_count = 0;
142		142
143	m_EnterTime = m_ec_env->GetTime();	143	m_EnterTime = enterTime;
144	m_InvokeTime = 0;	144	m_InvokeTime = 0;
145	m_EnterCpuTime = uiCpuNanos;	145	m_EnterCpuTime = uiCpuNanos;
146	m_InvokeCpuTime = 0;	146	m_InvokeCpuTime = 0;
Lines 156-172 Link Here
156	}	156	}
157	}	157	}
158		158
159	CStackEntry* AddStackEntry(MPI::TId methodId, U64 uiCpuNanos) {	159	CStackEntry* AddStackEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
160	if (m_pCallSet == 0) {	160	if (m_pCallSet == 0) {
161	m_pCallSet = new CStackEntry(m_ec_env, methodId, this, uiCpuNanos);	161	m_pCallSet = new CStackEntry(m_ec_env, methodId, this, enterTime, uiCpuNanos);
162	return m_pCallSet;	162	return m_pCallSet;
163	}	163	}
164	return m_pCallSet->AddSetEntry(methodId, uiCpuNanos);	164	return m_pCallSet->AddSetEntry(methodId, enterTime, uiCpuNanos);
165	}	165	}
166		166
167	CStackEntry* FinalizeStackEntry(U64 uiCpuNanos) {	167	CStackEntry* FinalizeStackEntry(U64 exitTime, U64 uiCpuNanos) {
168	m_count++;	168	m_count++;
169	U64 cumulativeTime = m_ec_env->GetTime() - m_EnterTime;	169	U64 cumulativeTime = exitTime - m_EnterTime;
170	U64 baseTime = cumulativeTime - m_InvokeTime;	170	U64 baseTime = cumulativeTime - m_InvokeTime;
171	m_baseTime += baseTime;	171	m_baseTime += baseTime;
172	U64 cumulativeCpuTime = uiCpuNanos - m_EnterCpuTime;	172	U64 cumulativeCpuTime = uiCpuNanos - m_EnterCpuTime;
Lines 182-194 Link Here
182	m_minTime = baseTime;	182	m_minTime = baseTime;
183	}	183	}
184	isActive = false;	184	isActive = false;
185	// TODO
186	return m_pCaller;	185	return m_pCaller;
187	}	186	}
188		187
189	CStackEntry* AddSetEntry(MPI::TId methodId, U64 uiCpuNanos) {	188	CStackEntry* AddSetEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
190	if (m_MethodId == methodId) {	189	if (m_MethodId == methodId) {
191	m_EnterTime = m_ec_env->GetTime();	190	m_EnterTime = enterTime;
192	m_InvokeTime = 0;	191	m_InvokeTime = 0;
193	m_EnterCpuTime = uiCpuNanos;	192	m_EnterCpuTime = uiCpuNanos;
194	m_InvokeCpuTime = 0;	193	m_InvokeCpuTime = 0;
Lines 196-204 Link Here
196	return this;	195	return this;
197	}	196	}
198	if (m_pNext != 0) {	197	if (m_pNext != 0) {
199	return m_pNext->AddSetEntry(methodId, uiCpuNanos);	198	return m_pNext->AddSetEntry(methodId, enterTime, uiCpuNanos);
200	}	199	}
201	m_pNext = new CStackEntry(m_ec_env, methodId, m_pCaller, uiCpuNanos);	200	m_pNext = new CStackEntry(m_ec_env, methodId, m_pCaller, enterTime, uiCpuNanos);
202	return m_pNext;	201	return m_pNext;
203	}	202	}
204		203
Lines 208-214 Link Here
208	}	207	}
209		208
210	// Partial memory cleaning in cg, counters reset	209	// Partial memory cleaning in cg, counters reset
211	void CleanMemory() {	210	void ClearInactive() {
212	if (!isActive) {	211	if (!isActive) {
213	m_baseTime = 0;	212	m_baseTime = 0;
214	m_baseCPUTime = 0;	213	m_baseCPUTime = 0;
Lines 216-231 Link Here
216	m_maxTime = 0;	215	m_maxTime = 0;
217	m_count = 0;	216	m_count = 0;
218	if (m_pCallSet != 0) {	217	if (m_pCallSet != 0) {
		218	m_pCallSet->ClearInactive();
219	delete m_pCallSet;	219	delete m_pCallSet;
220	m_pCallSet = 0;	220	m_pCallSet = 0;
221	}	221	}
222	} else {	222	} else {
223	if (m_pCallSet != 0) {	223	if (m_pCallSet != 0) {
224	m_pCallSet->CleanMemory();	224	m_pCallSet->ClearInactive();
225	}	225	}
226	}	226	}
227	if (m_pNext != 0) {	227	if (m_pNext != 0) {
228	m_pNext->CleanMemory();	228	m_pNext->ClearInactive();
		229	delete m_pNext;
		230	m_pNext = 0;
		231	}
		232	}
		233
		234	void ClearAll() {
		235	if (m_pCallSet != 0) {
		236	m_pCallSet->ClearAll();
		237	delete m_pCallSet;
		238	m_pCallSet = 0;
		239	}
		240	if (m_pNext != 0) {
		241	m_pNext->ClearAll();
		242	delete m_pNext;
		243	m_pNext = 0;
229	}	244	}
230	}	245	}
231		246
Lines 240-245 Link Here
240	}	255	}
241	}	256	}
242		257
		258	void SetCallSet(CStackEntry* callee) {
		259	m_pCallSet = callee;
		260	}
		261
243	private:	262	private:
244	JPIAgent::EC_Env* m_ec_env;	263	JPIAgent::EC_Env* m_ec_env;
245	CStackEntry* m_pCaller;	264	CStackEntry* m_pCaller;
Lines 285-307 Link Here
285	m_pNext = next;	304	m_pNext = next;
286	}	305	}
287		306
288	void AddStackEntry(MPI::TId methodId, U64 uiCpuNanos) {	307	void AddStackEntry(MPI::TId methodId, U64 enterTime, U64 uiCpuNanos) {
289	if (m_pFirstStackEntry == 0) {	308	if (m_pFirstStackEntry == 0) {
290	m_pFirstStackEntry = m_pCurrentStackEntry = new CStackEntry(m_ec_env, methodId, 0, uiCpuNanos);	309	m_pFirstStackEntry = m_pCurrentStackEntry = new CStackEntry(m_ec_env, methodId, 0, enterTime, uiCpuNanos);
291	return;	310	return;
292	}	311	}
293	if (m_pCurrentStackEntry == 0) {	312	if (m_pCurrentStackEntry == 0) {
294	m_pCurrentStackEntry = m_pFirstStackEntry->AddSetEntry(methodId, uiCpuNanos);	313	m_pCurrentStackEntry = m_pFirstStackEntry->AddSetEntry(methodId, enterTime, uiCpuNanos);
295	return;	314	return;
296	}	315	}
297	m_pCurrentStackEntry = m_pCurrentStackEntry->AddStackEntry(methodId, uiCpuNanos);	316	m_pCurrentStackEntry = m_pCurrentStackEntry->AddStackEntry(methodId, enterTime, uiCpuNanos);
298	}	317	}
299		318
300	void FinalizeStackEntry(U64 uiCpuNanos) {	319	int FinalizeStackEntry(U64 enterTime, U64 uiCpuNanos) {
301	// LOG_ASSERT(m_pCurrentStackEntry != 0); TODO check it
302	if (m_pCurrentStackEntry != 0) {	320	if (m_pCurrentStackEntry != 0) {
303	m_pCurrentStackEntry = m_pCurrentStackEntry->FinalizeStackEntry(uiCpuNanos);	321	m_pCurrentStackEntry = m_pCurrentStackEntry->FinalizeStackEntry(enterTime, uiCpuNanos);
		322	return 0;
304	}	323	}
		324	//such situation have to be fixed by adding new parent stack entry
		325	return -1;
305	}	326	}
306		327
307	void PrintAggCallGraph() {	328	void PrintAggCallGraph() {
Lines 312-329 Link Here
312	if (m_pFirstStackEntry != 0) {	333	if (m_pFirstStackEntry != 0) {
313	m_pFirstStackEntry->PrintStack(m_ThreadId);	334	m_pFirstStackEntry->PrintStack(m_ThreadId);
314	if (m_ec_env->isStackMemoryFree()) {	335	if (m_ec_env->isStackMemoryFree()) {
315	m_pFirstStackEntry->CleanMemory();	336	m_pFirstStackEntry->ClearInactive();
316	}	337	}
317	}	338	}
318	lockThreadObject->Leave();	339	lockThreadObject->Leave();
319	}	340	}
320		341
321	void Clear() {	342	void ClearInactive() {
322	if (m_pFirstStackEntry) {	343	if (m_pFirstStackEntry) {
323	m_pFirstStackEntry->CleanMemory();	344	m_pFirstStackEntry->ClearInactive();
324	}	345	}
325	}	346	}
326		347
		348	void ClearAll() {
		349	if (m_pFirstStackEntry) {
		350	m_pFirstStackEntry->ClearAll();
		351	m_pFirstStackEntry = 0;
		352	}
		353	}
		354
		355
		356	void SetNewRoot(MPI::TId methodId, U64 enterTime, U64 exitTime, U64 enterCpuNanos, U64 uiCpuNanos) {
		357	//ASSERT (m_pCurrentStackEntry == NULL)
		358	CStackEntry* newFirstStackEntry = new CStackEntry(m_ec_env, methodId, 0, enterTime, enterCpuNanos);
		359	newFirstStackEntry->FinalizeStackEntry(exitTime, uiCpuNanos);
		360	newFirstStackEntry->SetCallSet(m_pFirstStackEntry);
		361	m_pFirstStackEntry = newFirstStackEntry;
		362	m_pCurrentStackEntry = 0;
		363	}
		364
		365
		366
		367
327	OSA::IThreadSync* lockThreadObject;	368	OSA::IThreadSync* lockThreadObject;
328		369
329	private:	370	private: