Mfartura's blog : Intermediary

Real Case: IIS and Asp.Net hanging or poor performance (intermediary)

Marcelo Fartura — Thu, 26 Oct 2006 04:15:00 GMT

This week I'm working on this case related to IIS6 server hosting an Asp.Net application (it's a C# app) whose the performance is poor even when a very low number of users is hitting it. The architecture is the classical web layer accessing the backend DB servers and my goal is to isolate the problem, i.e pinpoint where the problem resides and try to find out why.

The first step after understanding the environment and being aware of all relevant servers and infrastructure devices, is to actually see the problem happening to have a better understanding of what is going on. We had one single user accessing the application and there are indeed some actions the user takes on the pages that take a long time to return, so the next step is to establish a baseline and agree on a SLA for the performance the application is supposed to have.

Another very important relevant point to this scenario is that since the environment counts on a NLB composed by multiple IIS servers, we need first to isolate which IIS server the client will connect to when we start trying to repro the problem. So after checking their NLB configuration and making sure they have the affinity set to single we can just open the IIS logs of the servers and search the client IP at the c-ip field. Since the affinity is single the server which has been serving the client will continue to be the same.

Once we know which server we will work with during the tests, my favorite tool to create the baseline is the System Monitor (perfrmon.exe) and we can also make some basic analysis of the IIS logs. So I set the perfmon with some specific counters that will help me to establish a baseline on how their app is currently behaving and also made sure they have the IIS log fields I need to work with when establishing the baseline.

The counters I used in the perfmon were the following:

ASP.NET v1.1.4322\Applications Running
ASP.NET v1.1.4322\Request Execution Time
ASP.NET v1.1.4322\Request Wait Time
ASP.NET v1.1.4322\Requests Current
ASP.NET v1.1.4322\Requests Queued
ASP.NET v1.1.4322\State Server Sessions Active
ASP.NET v1.1.4322\Worker Process Restarts
ASP.NET v1.1.4322\Worker Processes Running

The fields I needed to make sure are being included in the IIS logs are the following:

c-bytes

s-bytes

cs-uri-stem

cs-uri-query

time-taken

After that we reproduced the problem, which by the way was really happening with only one user accessing it which already eliminates any hypothesis of the problem being related to the amount of load hitting the server, we started working on the baseline.

The counters in perfmon pretty much confirm what we see in the IIS logs: Their main application page takes an average time longer than 40 seconds to execute. The perfmon counter “ASP.NET v.1.1.4322\Request Execution Time” will report that as well as the IIS logs if you use the LogParser tool and run the following query against them:

First we need to consolidate all the IIS logs in a single CSV file:

LogParser "select date,time,cs-uri-stem,cs-uri-query,sc-status,sc-win32-status,time-taken,sc-bytes,cs-bytes from ex061024.log, ex061025.log to merged.csv" -o:CSV

Now we run the following query to get the average time-taken for the URLs in the logs and send the output to a new CSV file named AvgTimeTaken.txt

logparser "select cs-uri-stem,count(cs-uri-stem), avg(time-taken) from merged.csv to AvgTimeTaken.txt where time-taken>=10000 GROUP BY cs-uri-stem ORDER BY avg(time-taken) DESC" -o:CSV -i:CSV

The result is as following:

cs-uri-stem	COUNT(ALL cs-uri-stem)	AVG(ALL time-taken)
/App/MainPage.aspx	15	48353
/App/MainPage.aspx	3	37738

Ok, now that we see the problem happening and have our baseline it’s time to start working on isolating problem.

We don’t know what exactly the user does in order to have the mainpage.aspx taking so long to execute, so what we do is try to reproduce the problem again and keep following the perfmon counter “ASP.NET v1.1.4322\Requests Current”. This method of tracking the “Requests Current” counter will not work for all scenarios, since when you have the server under some load you will likely not be able to tell when a specific request is taking long or not because there will be many requests at the same time and they will keep changing the value of “Requests Current”. For this cases we would need to have the collaboration of the user (which would tell us when the page is taking long to return) or look at other counters like the “Request Queued”. However for this specific scenario where we have the variables under control and there is a single user testing the system for us, it will work just fine.

When the “Requests Current” shows 1 request and don’t get back to zero after, let’s say, 10 seconds, that’s the point where we know this request is taking too long to execute. Remember that our baseline is around 40 seconds… Now it’s right time to generate a hung dump of the worker process. To do that we first run the iisapp.vbs script in order to identify the PID of the worker process hosting our application pool and after that we can use any tool to simply generate multiple hang dumps (like Debugging Tools For Windows or Debug Diagnostics Tool (DebugDiag)) some seconds apart from each other. In this case I used the adplus.vbs from Debugging Tools For Windows with the following sintaxe:

Adplus.vbs –hang –p 2364 –quiet –o c:\dumps

This will generate a memory dump of the w3wp.exe whose the PID is 2364 and store it at the c:\dumps folder.

The dumps analysis will require just some basic .Net debugging steps (I used the Windbg from Debugging Tools For Windows to analyze them) as below:

This is a managed application (it’s aspx) so we want to make sure we have, besides the proper symbols, the sos.dll extension properly loaded:

0:000> .chain

Extension DLL chain:

aspvbscriptext.dll: API 1.0.0, built Fri Feb 06 18:20:44 2004

[path: C:\debuggers\aspvbscriptext.dll]

mdacexts.dll: image 2004.05.11.1, API 1.0.0, built Tue May 11 17:46:12 2004

[path: C:\debuggers\mdacexts.dll]

webdbg: API 3.5.5, built Thu Nov 15 18:26:28 2001

[path: C:\debuggers\webdbg.dll]

sieext: API 1.0.0, built Fri Nov 05 16:07:40 2004

[path: C:\debuggers\winext\sieext.dll]

dbghelp: image 6.6.0005.0, API 6.0.6, built Fri Apr 14 17:03:13 2006

[path: C:\debuggers\dbghelp.dll]

ext: image 6.6.0005.0, API 1.0.0, built Fri Apr 14 17:02:35 2006

[path: C:\debuggers\winext\ext.dll]

exts: image 6.6.0005.0, API 1.0.0, built Fri Apr 14 17:02:30 2006

[path: C:\debuggers\WINXP\exts.dll]

uext: image 6.6.0005.0, API 1.0.0, built Fri Apr 14 17:02:37 2006

[path: C:\debuggers\winext\uext.dll]

ntsdexts: image 6.0.5357.0, API 1.0.0, built Fri Apr 14 17:21:31 2006

[path: C:\debuggers\WINXP\ntsdexts.dll]

clr10\sos: image 6.6.0005.0, API 1.0.0, built Fri Apr 14 17:02:47 2006

[path: C:\debuggers\clr10\sos.dll]

Ok, so once we know we have the right extension loaded, let’s start finding which threads are being used to process the Asp.Net mainpage.aspx. We expect to see only one thread here since our user is simply accessing this single page. By looking at the first dump we see the following:

0:000> !aspxpages

Loaded Son of Strike data table version 5 from "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\mscorsvr.dll"

Going to print all threads with ASP.NET Pages running.

Thread 11: /App/Mainpage.aspx

Ok, as we suspected there is only one thread processing the Asp.Net request and it’s the thread 11. Now let’s look on what this thread is currently doing:

0:011> !clrstack
Thread 11
ESP EIP
0x0604f4dc 0x7ffe0304 [FRAME: NDirectMethodFrameStandalone] [DEFAULT] UI2 System.Data.Common.UnsafeNativeMethods/Dbnetlib.ConnectionRead(ValueClass System.Runtime.InteropServices.HandleRef,SZArray UI1,UI2,UI2,UI2,ByRef I)
0x0604f4f8 0x069cf5e4 [DEFAULT] [hasThis] Void System.Data.SqlClient.TdsParser.ReadNetlib(I4) ß it seems we have some SQL stuff on the stack…
0x0604f558 0x069cf531 [DEFAULT] [hasThis] Void System.Data.SqlClient.TdsParser.ReadBuffer()
0x0604f560 0x069cf463 [DEFAULT] [hasThis] UI1 System.Data.SqlClient.TdsParser.ReadByte()
0x0604f568 0x069ced7a [DEFAULT] [hasThis] Boolean System.Data.SqlClient.TdsParser.Run(ValueClass System.Data.SqlClient.RunBehavior,Class System.Data.SqlClient.SqlCommand,Class System.Data.SqlClient.SqlDataReader)
0x0604f5b0 0x06aa3c79 [DEFAULT] [hasThis] Void System.Data.SqlClient.SqlDataReader.ConsumeMetaData()
0x0604f5c4 0x06aa3c0e [DEFAULT] [hasThis] SZArray Class System.Data.SqlClient._SqlMetaData System.Data.SqlClient.SqlDataReader.get_MetaData()
0x0604f5cc 0x06aa1be7 [DEFAULT] [hasThis] Class System.Data.SqlClient.SqlDataReader System.Data.SqlClient.SqlCommand.ExecuteReader(ValueClass System.Data.CommandBehavior,ValueClass

<cut for brevity>

So, the managed stack for the thread 11 seems to be waiting on SQL connection. The native stack would be at a ntdll!NtWaitingForSingleObject() function which basically means this thread is doing nothing but waiting. So let’s examine a little further to see if we can identify which results are we waiting from the SQL Server:

0:011> !dso
Thread 11
ESP/REG Object Name
eax 0x10073b34 System.Collections.Hashtable
ecx 0x10073b34 System.Collections.Hashtable
0x604f4c8 0x1801dad4 System.Byte[]
0x604f4d0 0x28061840 System.Data.SqlClient.TdsParser
0x604f4d4 0x1801dad4 System.Byte[]
0x604f4f8 0x28061840 System.Data.SqlClient.TdsParser
0x604f500 0x28090704 System.Data.SqlClient.SqlDataReader
0x604f504 0x28061840 System.Data.SqlClient.TdsParser
0x604f51c 0x28061840 System.Data.SqlClient.TdsParser
0x604f54c 0x2808fd28 System.Data.SqlClient.SqlCommand ß this is what we’re looking for

<cut for brevity>

Let’s taker a closer look at this specific object:

0:011> !do 0x2808fd28
Name: System.Data.SqlClient.SqlCommand
MethodTable 0x06854dd8
EEClass 0x0657fb60
Size 64(0x40) bytes
GC Generation: 0
mdToken: 0x02000194 (c:\windows\assembly\gac\system.data\1.0.5000.0__b77a5c561934e089\system.data.dll)
FieldDesc*: 0x068545c4
MT Field Offset Type Attr Value Name
0x79b80d44 0x40000b6 0x4 CLASS instance 0x00000000 __identity
0x0649824c 0x4000502 0x8 CLASS instance 0x00000000 site
0x0649824c 0x4000503 0xc CLASS instance 0x00000000 events
0x0649824c 0x4000501 0 CLASS shared static EventDisposed
>> Domain:Value 0x00099230:NotInit 0x000dfad8:0x100144d8 <<
0x06854dd8 0x4000eac 0x10 CLASS instance 0x10032b90 cmdText ß this string seems promising
0x06854dd8 0x4000ead 0x24 System.Int32 instance 4 cmdType
0x06854dd8 0x4000eae 0x28 System.Int32 instance 3600 _timeout
0x06854dd8 0x4000eaf 0x2c System.Int32 instance 3 _updatedRowSource
0x06854dd8 0x4000eb0 0x38 System.Boolean instance 0 _inPrepare
0x06854dd8 0x4000eb1 0x30 System.Int32 instance -1 _handle
0x06854dd8 0x4000eb2 0x14 CLASS instance 0x28090450 _parameters
0x06854dd8 0x4000eb3 0x18 CLASS instance 0x2808f624 _activeConnection
0x06854dd8 0x4000eb4 0x39 System.Boolean instance 0 _dirty
0x06854dd8 0x4000eb5 0x3a System.Byte instance 0 _execType
0x06854dd8 0x4000eb6 0x1c CLASS instance 0x00000000 _cachedMetaData
0x06854dd8 0x4000eb7 0x34 System.Int32 instance -1 _rowsAffected
0x06854dd8 0x4000eb8 0x3b System.Boolean instance 0 designTimeVisible
0x06854dd8 0x4000eb9 0x20 CLASS instance 0x00000000 _transaction

Looking at such an instance:

0:011> !do 0x10032b90
Name: System.String
MethodTable 0x79b7daf8
EEClass 0x79b7de44
Size 80(0x50) bytes
GC Generation: 2
mdToken: 0x0200000f (c:\windows\microsoft.net\framework\v1.1.4322\mscorlib.dll)
String: dbo.[spGenerateOptions] ß Bingo!!! This is the stored procedure we’ve been waiting on to return
FieldDesc*: 0x79b7dea8
MT Field Offset Type Attr Value Name
0x79b7daf8 0x4000013 0x4 System.Int32 instance 31 m_arrayLength
0x79b7daf8 0x4000014 0x8 System.Int32 instance 30 m_stringLength
0x79b7daf8 0x4000015 0xc System.Char instance 0x64 m_firstChar
0x79b7daf8 0x4000016 0 CLASS shared static Empty
>> Domain:Value 0x00099230:0x28000224 0x000dfad8:0x28000224 <<
0x79b7daf8 0x4000017 0x4 CLASS shared static WhitespaceChars
>> Domain:Value 0x00099230:0x28000238 0x000dfad8:0x2000364c <<

So we know that at the point this dump was taken we were just waiting at the stored procedure spGenerateOptions to complete it’s execution at a SQL Server.

We are going now to look at the subsequent dump (taken 30 seconds later) to verify whether we have any progress or not on that thread, however let’s take a loot at one last thing on this dump before starting with the other one (this can save us a lot of time here):

0:011> !runaway

User Mode Time

Thread Time

13:d5c 0 days 0:00:37.500

14:c00 0 days 0:00:24.718

16:9c8 0 days 0:00:16.406

15:9e8 0 days 0:00:13.562

11:bb8 0 days 0:00:12.015 ß This is the CPU time spent by the thread 11 at this point

So we know that the thread 11 have had the CPU for the aprox. 12.015 seconds when this dump was generated. So after opening the second dump, before jumping on any deeper analysis, lets just run the same command and verify if the thread 11 made any progress.

0:011> !runaway

User Mode Time

Thread Time

13:d5c 0 days 0:00:37.500

14:c00 0 days 0:00:24.718

16:9c8 0 days 0:00:16.406

15:9e8 0 days 0:00:13.562

11:bb8 0 days 0:00:12.015 ß The time is exactly the same 30 seconds later

Ok, so there is not a single additional millisecond being spent by the thread 11 on the second dump. At this point we don’t even need to take a look at the thread stack to know it’s exactly the same. In other words this thread has been doing nothing but waiting on that stored procedure to execute at the SQL Server.

The problem has been isolated as a database performance issue (mission accomplished!!! J). The next step is work on the database server (running in another box) to understand why this sp is taking too long to execute and, of course, properly addressing the issue to provide a definitive solution. IIS ended up just being the server where the symptom is faced and not the one where the root cause of the problem is really happening.

Troubleshooting IIS 100% CPU issues - Step by Step (intermediary)

Marcelo Fartura — Fri, 15 Sep 2006 02:17:00 GMT

Processes consuming 100% of a system's CPU time is such a situation everybody has faced at least once (likely much more than once :)), and normally as solution we just "kill the murderer" by stopping the culprit process. But what was really causing that process to behave like that? If you can't properly answer this question you might be convicted to repeat the "kill the murderer" process forever...

The procedures we will see below are general enough for troubleshoot any application causing the 100% CPU situation, however I will use IIS as an example here since, as a custom application's host, it is one of the products whereby this situation happens very often.

Notice: This has been classified as an intermediary level content, so it presumes you understand concepts like memory dumps, crashes, hangs, applications, processes, threads, call stacks etc, and also have some experience with debugging.

Before the problem happens...

Step 1:
Make sure you are familiar with and have the proper tools we will need for the further steps. We will need the System Monitor (perfmon.exe), the Debugging Tools for Windows package installed (preferably installed at the c:\debuggers folder) and if possible the proper symbol files.

You will also need some basic understanding about the IIS architecture.

Step 2:
Run the System Monitor (perfmon.exe), in a remote machine if possible, and create a new Counter Log: Chose any name, lets say "Performance_log". After confirming the name you've just chosen, in the General Tab, click in Add Objects and choose "Select counter objects from comupter". In the combo list, select or type the remote computer name (the one where the problem happens and which you're going to monitor)

Select the following objects::counters:

Processor(*)\*
Process(*)\*
Threads(*)\*

Start monitoring and wait until the server gets the high CPU utilization issue

When the problem happens...

Step 3:
First confirm that is an IIS process (any w3wp.exe for IIS6, inetinfo.exe or any dllhost.exe for IIS5/5.1 of inetinfo.exe or any MTX.exe - IIS4) that is consuming the CPU time. You can use even the task manager (CPU and Process columns) to confirm that.

After identifying which process is consuming the CPU time, take a note of the Process ID of such a process from task manager. You can also use other tools like tasklist.exe (builtin for Windows XP and Windows 2003) or tlist.exe from the Debugging Tools for Windows. For IIS5 servers, if you want to know what application is being hosted by the process (in case of a DLLHOST.EXE) you can use the Component Services mmc or simply run the following command from a command prompt:

c:\debuggers\>tlist -k | find /i "dllhost.exe"

It will list all the DLLHOST.EXE process and the respective applications being hosted by the processes in following output format:

C:\Debuggers>tlist -k | find /i "dllhost"
3496 dllhost.exe     MyCom+ Application 01
4892 dllhost.exe     MyCom+ Applicatoin 02
4900 dllhost.exe     IIS Out_Of_Proc_Pooled
3840 dllhost.exe     Mts:   System Application

For the IIS4, the same assumption is valid except that you have MTS Explorer instead and the surrogate name will change from dllhost.exe to mtx.exe.
For the IIS6 however, you can't use Component Services (IIS6 doesn't rely on COM+ for creating the surrogates as IIS5 does) nor tlist.exe to identify the applications being hosted by the processes. You will need to use the script iisapp.vbs instead (it's built in script for Windows 2003). Run iisapp from a command prompt with no parameters and it will return a list with the w3wp.exe processes, their PID and the application pools being hosted by them.

Step 4:
Once you've identified the PID (process ID) the CPU consumer you're ready to generate a hang memory dump (please note that the dump will contain useful information only, and if only, it was taken while the problem was happening). To generate the dump execute the following commands from a command prompt:

C:\Debuggers\>cscript adplus.vbs -hang -p <PID> -quiet -o c:\dumps

Adplus will spawn a debugger (cdb.exe) which will attach to the process, generate the hang dump and dettach itself. If you're familiar with the Debug Diagnostics Tool package (DebugDiag), feel free to use it. It doesn't matter which tool you will use as long as you generate a good full dump.

Generally is a good practice to generate more 1 or 2 dumps repeating above procedure 1 minute apart from each other. This might be useful when analyzing the problem cause.

Once the adplus.vbs is done, stop the perfmon log. At this point you can also apply the workaround (likely kill the process) you've been applying to make your server reponsive again.

Analyzing the data...

Step 5:
Open the perfmon log:

Run perfmon , select System Monitor on the left navigation bar and type Ctrl + Q to open the properties window.
Click in the Source tab and select Log Files. Click add and select the c:\perflogs\Performance_log000001.blg file and click ok.

Press Ctrl + I, or press the "+" button, to add objects and counters.
Select Process object, and the %Processor Time counter, select all the IIS related processes, click add then close.

The system monitor window will show the %CPU utilization of each process. Press Ctrl+ B to change the view to histogram. Determine the highest bar and double click it.

Press Ctrl+ H to confirm you selected the highest bar on the histigram view. Determine which process is the one that owns the highest bar. It must to be the same as the one you identified on the task manager as the culprit.

Press Ctrl + E to clean the histogram window and press CTRL + I to include new counters.

Select thread object, select %Processor Time counter and select all the instances of the process you determined as the culprit one.

Repeat the same process as before to determine which thread is the one consuming CPU - tip: Histogram is the best view to do that.

Once you know the process and thread within the process that is consuming the CPU, clean the perfmon System Monitor window one more time - Ctrl + E

Press Ctrl + I and select the Thread object again. Select the ID thread counter and select the instance of the previous determined thread. Click add and close. See how to simplify the Thread and Process ID identification in the perfmon in this article.

In the System Monitor Window, determine the thread ID of thread by looking at Min, Max and Avg values. THey should be all the same. If they are not the same is because you have monitored for a longer period than the high CPU utilization one. If that happened press Ctrl + Q, go to source tab and move the Time WIndow slide in order to get only the period of high utilization CPU, then go back to System Monitor Tool and chek for thread ID again.

Convert the Thread ID value from decimal to hexadecimal and take a note of this hex value.

How about some debugging now?

Step 6:
Open the Windbg.exe from the c:\debuggers folder.
Press Ctrl + D and select the hang dump (.dmp file) you generated earlier by uging adplus.vbs (they should be placed in the folder c:\dumps based on the option "-o c:\dumps" used before)

Close the Disassembly window if it opens (some versions of Windbg will do it autommaticaly)

Make sure your symbol path is properly set (remember to use the command !symfix or set it manually to http://msdl.microsoft.com/download/symbols) and run the .reload /s command if you needed to change the symbol path.

On the Windbg's command prompt type ~ and press enter. A thread list will show up as the example below:

0:00> ~
   0 Id: f4.f3 Suspend: 1 Teb: 7ffde000 Unfrozen
   1 Id: f4.f7 Suspend: 1 Teb: 7ffdd000 Unfrozen
   2 Id: f4.10a Suspend: 1 Teb: 7ffdb000 Unfrozen
   3 Id: f4.10f Suspend: 1 Teb: 7ffda000 Unfrozen
   4 Id: f4.110 Suspend: 1 Teb: 7ffd9000 Unfrozen
   5 Id: f4.111 Suspend: 1 Teb: 7ffd8000 Unfrozen
   6 Id: f4.112 Suspend: 1 Teb: 7ffd7000 Unfrozen
   7 Id: f4.115 Suspend: 1 Teb: 7ffd6000 Unfrozen
   8 Id: f4.116 Suspend: 1 Teb: 7ffd5000 Unfrozen
   9 Id: f4.117 Suspend: 1 Teb: 7ffd4000 Unfrozen
10 Id: f4.11a Suspend: 1 Teb: 7ffae000 Unfrozen
11 Id: f4.11b Suspend: 1 Teb: 7ffad000 Unfrozen
12 Id: f4.129 Suspend: 1 Teb: 7ffac000 Unfrozen
13 Id: f4.12a Suspend: 1 Teb: 7ffab000 Unfrozen
14 Id: f4.12e Suspend: 1 Teb: 7ffaa000 Unfrozen

The Id: identificator above is followed by the PID.TID where PID is the hex representation of the process ID and TID is the hex representation of the thread ID.

Find the one which has the thread ID you determined before. Tip: you can convert from hex to decimal by the the "?" in the debugger's command prompt. Ex.: "? f4" will generate the following output:

0:00> ? f4
Evaluate expression: 244 = 000000f4

Once you identified the thread in the list you have two options to set this thread's context the active one. You run the following command with using the TID:

~~[TID]s

Or you run the following command using the corresponding thread number (#):

~#s

Both command will produce the same result which is set the thread's context the active one in the debugger. Now you can check the thread stack to see what is causing the high CPU utilization by just typing one of stack commands (k). For example, the kb command will show you the stack with the some additional information like the three first arguments passed through the functions as below:

0:065> kb
ChildEBP RetAddr Args to Child
07c7bc20 623016d6 60a27460 07c7bff8 00000200 oran8!nnciqdn+0xab
07c7bd3c 60b2695a 60a27460 00298880 07c7bff8 orantns8!nnftboot+0x6d6
07c7bd68 60b25881 00298880 07c7bff8 00000200 oran8!nnfgqdn+0x3a
07c7bdc0 60a10acf 60a27460 07c7e630 00000000 oran8!nnfgrne+0x2c1
07c7c418 60b6e222 60a27460 07c7e630 00000016 oranl8!nlolgobj+0x6df
07c7c458 60b27be0 60a27460 07c7e630 00298930 oran8!sntseltst+0xc072
07c7c488 60b16472 60a27460 07c7e630 000000ff oran8!nnfsn2a+0x30
07c7d600 60b60ebc 60a27460 00001803 07c7e630 oran8!niqname+0x252
07c7f76c 604b0c93 07c7e630 00000007 00001803 oran8!osncon+0x23c
07c7f94c 604b849e 07012e44 14414d22 00000007 ORACLIENT8!xaolog+0x1f533
07c7f970 604b84ea 14414df8 14414d22 00000007 ORACLIENT8!xaolog+0x26d3e
07c7f98c 604ba15d 14414df8 14414d22 00000007 ORACLIENT8!xaolog+0x26d8a
07c7fe44 604bb128 14414df8 14414cf6 0000002b ORACLIENT8!xaolog+0x289fd
07c7fe84 6047fed4 14414df8 14414cf6 ffffffff ORACLIENT8!xaolog+0x299c8
07c7febc 604614a0 14414df8 14414cf6 ffffffff ORACLIENT8!upilog+0x64
07c7fef0 10002642 14414db8 14414df8 14414cf6 ORACLIENT8!ocirlo+0xb0
07c7ff84 7800265a 14414b90 01b0ed14 7800ef03 ociw32!olog+0x62
07c7ffb8 77f04ef0 00297850 01b0ed14 7800ef03 MSVCRT!beginthreadex+0xb2
07c7ffec 00000000 780025ff 00297850 00000000 KERNEL32!lstrcmpiW+0xbe

By looking at thread stack you should be able to identify what is causing the high CPU utilization problem. You can always unassembly (u) from the intruction pointer to try digging a little bit more and obtain some additional information. Ex.:

0:065> u eip
oran8!nnciqdn+0xab:
60b1fefb 8b10            mov     edx,dword ptr [eax]
60b1fefd 83c004          add     eax,4
60b1ff00 52              push    edx
60b1ff01 50              push    eax
60b1ff02 8b4510          mov     eax,dword ptr [ebp+10h]
60b1ff05 53              push    ebx
60b1ff06 50              push    eax
60b1ff07 56              push    esi

I will post a real case analysis very soon in this blog...