Este artículo proviene de un motor de traducción automática.
Seguimiento de eventos para Windows
Eventos principales de instrumentación en Windows 7, parte 2
Dr. Insung Park y de Alex Bendetov
Bienvenido de nuevo para la segunda parte de nuestra serie de artículo de dos partes: Eventos de Instrumental de principales en Windows 7. En el primer artículo, se presenta una descripción general de la instrumentación de OS principales y de tecnología de seguimiento de eventos para Windows (ETW). También hemos tratado la compatibilidad de la herramienta para obtener y consumir eventos del sistema operativo. En esta segunda parte, seguimos proporcionan más detalles sobre los eventos desde varios subcomponentes en el núcleo del sistema operativo. También se explica cómo se pueden combinar los sucesos diferentes del sistema para generar una imagen completa del comportamiento del sistema, que se muestra mediante un conjunto de secuencias de comandos de Windows PowerShell.
Disco, archivo, detalles de archivos y eventos de controladores
Desde la perspectiva del programa, operaciones como la apertura, lectura o escritura de archivos son la forma tener acceso al contenido en el disco. Debido optimizaciones, como almacenamiento en caché y la captura previa de datos, no todas las solicitudes de E/S de archivos producir acceso al disco inmediatamente. Además, se puede distribuir contenido del archivo a través de discos y determinados dispositivos de disco admiten reflejo y la creación de bandas y así sucesivamente. Para estos casos, leer un bloque de datos de un archivo traduce accesos varios a uno o más discos. Los eventos de cuenta de acceso de archivo y disco para inicio de E/S de archivo, finalización de E/S de archivo, inicio de acceso de disco, disco acceso final, dividir la E/S, las actividades de controlador y mapas de archivo (nombre de clave única).
Una solicitud de una aplicación de usuario para tener acceso a un archivo y la finalización correspondiente de esa solicitud a la aplicación de usuario viaja a través de una pila de varios componentes. En el sistema es Windows, las operaciones de E/S están registradas por una entidad denominada un paquete de solicitud de E/S (IRP). Una operación de E/S iniciada por el usuario se convierte en un IRP cuando entra en el Administrador de E/S. Como un IRP recorre una cadena de componentes, cada componente realiza las tareas necesarias para procesar la solicitud, actualiza el IRP y lo pasa en, si es necesario, para el componente controlará la solicitud siguiente. Cuando se cumplen todos los requisitos de solicitud de E/S (en un caso sencillo, un bloque solicitado de un archivo se recupera desde un disco), se denominan finalización registrado rutinas para realizar cualquier procesamiento adicional de los datos y los datos solicitados se devuelven a la aplicación de usuario.
En un nivel superior en el núcleo del sistema de E/S, eventos de E/S de archivo de registro las operaciones emitidas por una aplicación. Eventos de E/S de archivos incluyen los siguientes tipos: Crear, leer, escribir, Flush, cambiar nombre, eliminar, limpieza, cerrar, establecer información, información de consulta, Active (enumeración) y Active notificación de cambio. Operaciones, como crear, lectura, escritura, alinear, cambiar nombre y eliminación son sencillas y contienen elementos de datos como archivo clave, E/S puntero (IRP) del paquete de solicitud, tamaño del bloque y desplazamiento en el archivo, según sea necesario. Sucesos de conjunto de información y consultar información indican que los atributos de archivo se han establecido o consultar. Se registra un suceso de limpieza cuando se cierra el último identificador en el archivo. Un evento de cierre especifica que se está liberando un objeto de archivo. Enumeración del directorio y notificación de cambiar de directorio sucesos se registran cuando se enumera un directorio o una notificación de cambio de directorio se envía a agentes de escucha registrados, respectivamente. Eventos de E/S de archivos se registran en ETW cuando se solicita la operación. Aquellos que están interesados en la finalización y la duración de las operaciones de E/S de archivo pueden habilitar eventos de finalización de E/S de archivo, que se puedan correlacionar los eventos de E/S de archivo original a través del puntero IRP. Eventos de finalización de E/S de archivos registran IRP puntero y devuelven estado.
Se registran sucesos de disco en un nivel inferior de la pila de E/S y contienen información específica de acceso de disco. Leer y escribir operaciones de lectura de disco de generar y eventos de escritura que contiene el disco número, tamaño de transferencia de desplazamiento a la dirección que se tiene acceso, puntero IRP y tiempo de respuesta del acceso de bytes. Eventos de vaciado registran las operaciones de vaciado de disco. A diferencia de E/S de archivo eventos que se registran al principio de operaciones, en la hora de finalización de E/S se registran eventos de E/S de disco. Los usuarios tienen la opción para recopilar eventos de inicialización de E/S de disco adicionales para todos los eventos de E/S de disco (eventos de ReadInit WriteInit y FlushInit). Como se mencionó anteriormente, no todos los eventos de E/S de archivo tienen eventos coincidentes de E/S de disco, si por ejemplo el contenido solicitado ya está disponible en la caché o una escritura en la operación de disco se almacena en búfer. Eventos de división es indican que se han dividido las solicitudes de E/S en varias solicitudes de E/S de disco debido a que el hardware subyacente reflejo de disco. Los usuarios sin dicho hardware no podrán ver eventos de división es incluso si les permiten. Asigna al elemento primario original IRP en varios secundarios IRP.
E/S de disco, E/S de archivo y eventos de división es contengan claves de archivo único creadas para los archivos abiertos. Esta clave de archivo puede utilizarse para realizar un seguimiento relacionados con operaciones de E/S dentro del sistema de E/S. Sin embargo, el nombre de archivo real para la operación de archivo no está disponible en los eventos de archivo o de E/S de disco. Para resolver el nombre de los archivos, son necesarios los eventos de detalles del archivo. Se enumeran todos los archivos abiertos para registrar sus claves de archivo y nombres. En un equipo de estado simulada, objetos de archivo de seguimiento se realiza en términos de claves de archivo, para registrar la E/S de archivos las solicitudes y accesos a disco real y los nombres se actualizan en los objetos cuando se producen eventos de detalles del archivo. Por una razón histórica, claves del archivo en eventos de E/S de disco y detalles de archivos se denominan FileObject. La mayoría de los eventos de E/S de archivo contienen el objeto de archivo y clave de archivo.
Controlador de eventos indican las actividades de controladores, que, dependiendo del tipo de dispositivo pueden o no se pueden solapar con actividades de E/S de disco. Controlador de eventos pueden ser de interés para los usuarios familiarizados con el modelo de controlador de Windows (WDM). La instrumentación de controlador agrega eventos de llamadas de función de controlador de E/S y rutinas de finalización. Controlador de eventos contengan datos de controlador como clave de archivo, puntero IRP y direcciones de rutinas (principal y secundaria función y de finalización de rutina), según corresponda para tipos de eventos individuales.
Eventos de E/S normalmente como resultado un gran volumen de eventos, que puede necesitar aumentar el número o el tamaño de los búferes para la sesión del núcleo (-nb opción logman). Además, los eventos de E/S son útiles en analizar archivo usos, patrones de acceso de disco y las actividades de controlador. Sin embargo, los valores de id de proceso y subproceso de los eventos de E/S, con la excepción de eventos de E/S de disco, no son válidos. Para correlacionar estas actividades correctamente para el subproceso original y, por lo tanto, el proceso, uno debe considerar el seguimiento de eventos de cambio de contexto.
Eventos de red
Los sucesos de red se registran cuando se producen las actividades de red. Los eventos de red de la sesión de núcleo se emiten en capas en TCP/IP y UDP/IP. Eventos de TCP/IP se registran cuando realizará las acciones siguientes: Enviar, recibir, desconectar, retransmisión, volver a conectar, copiar y error. Todas contienen el tamaño de paquete, direcciones IP de origen y destino y puertos, excepto para eventos de error ya que hay información disponible. Además, la moneda original procesar id para enviar eventos de tipo y el identificador de proceso de destino para recibir eventos de tipo se incluyen ya que a menudo estas operaciones de red no se realizan en el contexto de proceso de origen y recepción. Esto significa que los eventos de red se pueden atribuir a un proceso, pero no a un subproceso. Eventos UDP/IP están bien enviar o recepción los sucesos, que incluyen los elementos de datos enumerados anteriormente. Por último, cada tipo de operación (enviar, recibir etc.) corresponde a un par de eventos: uno para el protocolo IPv4 y el otro para IPv6. Se han agregado eventos para el protocolo IPv6 en Windows Vista.
Eventos de registro
La mayoría de operaciones de registro están instrumentadas con ETW y estos eventos se pueden atribuir a procesos y subprocesos a través de los identificadores de proceso y subproceso en el encabezado de evento. La carga de evento de registro no contiene un nombre de clave del registro completo. En su lugar, incluye una clave única, se ha indicado como bloque de control de clave (KCB), para cada clave del Registro abierta. Al final de una sesión de núcleo se registran sucesos detención que estas claves se asignan a los nombres de registro completo. Para resolver el registro de nombres, uno debe utilizar una técnica similar que se utiliza para la resolución de nombre archivo, en el que estos asignan eventos se utilizan para actualizar objetos del registro en el equipo de estado. Sucesos del Registro han sido útiles analizar patrones de acceso y identificar redundante tiene acceso para la optimización. La carga de evento de registro contiene el estado devuelto de la operación, que puede utilizarse para supervisar errores de operación de registro y solucionar problemas de posibles de la aplicación.
Figura 1 Script Get-ETW PID lista de tabla de proceso de impresión
<####################
# Get-ETW-PID-List
# \@brief Takes in an XML stream and prints the list of process names
# with PIDs that were detected in the incoming stream.
####################>
function Get-ETW-PID-List([Switch] $print) {
begin {
$pidlist = new-object System.Collections.Hashtable
$procid = 0
$procname = ""
}
process {
$xmldata = $_
# For each Process event, grab process id and binary name
# and add to the list.
foreach ($e in $xmldata.Events.Event) {
if ($e.RenderingInfo.EventName.InnerText -eq "Process") {
foreach ($d in $e.EventData.Data) {
# Grab process id.
if ($d.Name -eq "ProcessId") {
$procid = $d.InnerText
# Grab the process name.
} elseif ($d.Name -eq "ImageFileName") {
$procname = $d.InnerText
}
}
if (!$pidlist.Contains($procid)) {
$pidlist.add($procid, $procname) | Out-Null
}
}
}
}
end {
remove-variable xmldata
if ($print) {
"{0,-29}| PID" -f "Binary Name"
"-------------------------------------"
foreach ($item in $pidlist.Keys) {
"{0,-30}({1})" -f $pidlist.$item,$item
}
} else {
return $pidlist
}
}
}
Figura 2 salida de Get-ETW PID lista secuencia de comandos
PS C:\tests> $xmldata | Get-ETW-PID-List -print
Binary Name | PID
-------------------------------------
dwm.exe (2776)
powershell.exe (2384)
svchost.exe (708)
notepad.exe (4052)
iexplore.exe (4284)
...
iexplore.exe (4072)
svchost.exe (3832)
smss.exe (244)
System (4)
spoolsv.exe (1436)
Idle (0)
Eventos de perfil basado en el ejemplo
Eventos de perfil basado en el ejemplo (eventos de perfil, adelante) permiten seguimiento donde CPU dedicar su tiempo. Eventos de perfil pueden utilizarse para calcular una buena aproximación de utilización de la CPU. Cuando están habilitados los eventos de perfil, el núcleo de Windows activa perfiles interrupciones, que hace que se registrarán de cada procesador a una velocidad fija (el valor predeterminado es 1000 veces por segundo en cada procesador) los eventos de perfil. Debe tenerse en cuenta que en modo de bajo consumo de energía en algunos equipos, los eventos de perfil pueden estar desactivados temporalmente. La carga de eventos de perfil está formado por el identificador de subproceso del subproceso que actualmente está ejecutando en ese procesador y el valor del registro de puntero de instrucción en el momento de la interrupción de generación de perfiles. En Windows 7, la carga de eventos de perfil también contiene indicadores necesarios para identificar el contexto de ejecución (subproceso o DPC/ISR).
Script de Get-ETW PID información de la figura 3 para detalles de proceso de impresión
<####################
# Get-ETW-PID-Info
# \@brief Retrieves various information about a particular process id
####################>
function Get-ETW-PID-Info([Int] $p, [switch] $i, [switch] $t) {
begin {
$threadlist = New-Object System.Collections.ArrayList
$imagelist = New-Object System.Collections.ArrayList
$procname = ""
}
process {
$xmldata = $_
$sievedxml = $($xmldata | Get-ETW-PID-Events $p).$p
foreach ($e in $sievedxml.Events.Event) {
if ($e.RenderingInfo.EventName.InnerText -eq "Process") {
foreach ($d in $e.EventData.Data) {
# Grab the process binary name
if ($d.Name -eq "ImageFileName") {
$procname = $d.InnerText
}
}
}
if ($e.RenderingInfo.EventName.InnerText -eq "Image") {
foreach ($d in $e.EventData.Data) {
# Grab the loaded image name and add it to the list
if ($d.Name -eq "FileName") {
if (!$imagelist.contains($d.InnerText)) {
$imagelist.add($d.InnerText) | Out-Null
}
}
}
}
if ($e.RenderingInfo.EventName.InnerText -eq "Thread") {
foreach ($d in $e.EventData.Data) {
# Grab thread id and add it to the list
if ($d.Name -eq "TThreadId") {
$tid = $d.InnerText
if (!$threadlist.contains($tid)) {
$threadlist.add($tid) | Out-Null
}
}
}
}
}
}
end {
"Process Name: $procname"
if ($t) {
"Thread List: ($($threadlist.Count))"
$threadlist | Sort -descending
} else {
"Thread Count: $($threadlist.Count)"
}
if ($i) {
"Image List ($($imagelist.Count)):"
$imagelist | Sort
} else {
"Images: $($imagelist.Count)"
}
}
}
LA utilización de la CPU se puede aproximada con eventos de perfil, que es el porcentaje de eventos de perfil con identificadores de subproceso distinto del que el subproceso inactivo. Distribución de uso de CPU por proceso requiere un paso más de los identificadores de subproceso en las cargas de eventos de perfil de seguimiento de procesos individuales. Si una máquina de estado está disponible con eventos de proceso y subproceso como se describe en la parte 1 de esta serie de artículo de dos partes, es muy sencillo generar un informe de uso de CPU por proceso. También es posible realizar seguimiento de uso de CPU a un módulo cargado a través de eventos de carga de imagen. Comparando el puntero de instrucción con el intervalo de direcciones de resultados de los módulos cargados en la ubicación de los punteros de instrucción para una imagen binaria y, por lo tanto, para un perfil de uso de CPU por módulo. Si símbolos binarios están disponibles, uno puede obtener los nombres de función de los punteros de instrucción mediante la biblioteca DbgHelp. Con pilas de llamadas habilitadas para los eventos de perfil, incluso uno puede deducir cómo se invoca la función. Esto es muy útil cuando el puntero de instrucción apunta a una función de biblioteca utilizados con frecuencia.
Eventos de subproceso preparado
Hay varias razones por qué el sistema cambiará fuera un subproceso en ejecución. Uno de los motivos más comunes es que debe esperar a finalizar las tareas relacionadas antes de pueda continuar otros subprocesos. Tales dependencias en la superficie de la ejecución como subprocesos que se impide la ejecución mientras se espera un objeto para establecerse, como eventos, semáforo, temporizador y así sucesivamente. El programador de Windows (también conocido como distribuidor) realiza un seguimiento de convertirse en desbloqueada por otro subproceso, una DPC o un temporizador de subprocesos. Las dependencias entre componentes y subprocesos no fácilmente son vistas y predecir durante el desarrollo. Cuando realizará retrasos imprevistos, resulta difícil realizar el seguimiento a la causa del problema.
Eventos de subproceso (o el distribuidor) preparados se agregaron a diagnosticar estos problemas. Cuando un subproceso está desbloqueado (o readied) y en la cola del distribuidor listo, se registra un suceso de subproceso preparado, cuya carga contiene el identificador de subproceso del subproceso readied. Al siguiente la cadena de eventos de subprocesos listos, uno puede realizar un seguimiento la cadena de dependencia de ejecución como lo que se desarrolla. Sucesos de cambio de contexto, presentados anteriormente, indican cuando el subproceso readied realmente está programado para ejecutarse. Las pilas de llamadas habilitan para los eventos de subproceso preparado pueden provocar el punto en el código de responsable de desbloqueo del subproceso de espera. Eventos de subproceso preparados están recién disponibles en Windows 7.
Sucesos de llamada del sistema
Eventos de llamada de sistema denotan entradas en y sale fuera de llamadas de sistema sistema operativo de Windows principal. Llamadas del sistema son la interfaz en el núcleo de Windows, formada por un número de API. Se agregó esta instrumentación para supervisar las llamadas del sistema realizadas por las aplicaciones de modo de usuario y componentes de modo de núcleo. Hay dos tipos de eventos de llamadas de sistema. Un evento de sistema llamada escriba indica una invocación de una llamada del sistema y registros de la dirección de la rutina correspondiente al servicio del sistema invocado. Un evento de llamada salir del sistema indica una salida desde una llamada de sistema y su carga contiene el valor devuelto de la llamada a la API. Son útiles para análisis estadístico en actividades de llamada del sistema y las latencias de los eventos de llamada de sistema, pero como algunos de los eventos de E/S y memoria, se registran sin actual información de id de proceso y subproceso en el encabezado. Para relacionar las actividades de llamada de sistema con procesos y subprocesos, uno debe recopilar eventos de cambio de contexto al mismo tiempo y, durante la simulación de la máquina de estado, realizar un seguimiento del subproceso actual está ejecutando en las CPU con el identificador de CPU en el evento de encabezado de los eventos de llamadas de sistema, como se describe en la parte 1 de esta serie de artículo de dos partes.
Avanzada eventos de llamada a procedimiento local
Llamada a procedimiento local (LPC) ha sido un mecanismo de comunicación entre procesos (IPC) de local eficaz en las plataformas Windows durante años. Windows Vista proporciona un medio más eficaz y seguro para las necesidades IPC, denominado llamada a procedimiento local avanzado (ALPC). ALPC también se utiliza como mecanismo de transporte para locales (RPC). El componente ALPC está instrumentado con ETW, emitir enviar, recibir, esperar respuesta de nuevo, esperar mensaje nuevo y Unwait eventos.
Sucesos de la configuración del sistema
Cuando finaliza la sesión del núcleo, ETW registra varios sucesos que describen la configuración del sistema del equipo en el que se recopilan los eventos. En muchos escenarios de análisis de rendimiento, conocer la configuración de software y hardware subyacente ayuda considerablemente en comprender el comportamiento del sistema, especialmente cuando el equipo en el que se analizan los eventos es diferente del equipo donde se recopilan los eventos. Estos eventos de configuración del sistema proporcionan información sobre CPU, tarjetas gráficas, tarjetas de red, dispositivos Plug and Play, dispositivos IDE, configuración de disco físico y lógico y servicios. La carga de eventos de configuración del sistema varía en función del dispositivo o configuración que describe pero normalmente contiene cadenas de descripción y especificaciones clave.
Figura 4 resultados desde el Script Get-ETW PID información
PS C:\tests> $xml | Get-ETW-PID-Info 4052 -i
Process Name: notepad.exe
Thread Count: 2
Image List (31):
\Device\HarddiskVolume2\Windows\System32\advapi32.dll
\Device\HarddiskVolume2\Windows\System32\dwmapi.dll
\Device\HarddiskVolume2\Windows\System32\gdi32.dll
\Device\HarddiskVolume2\Windows\System32\imm32.dll
\Device\HarddiskVolume2\Windows\System32\kernel32.dll
\Device\HarddiskVolume2\Windows\System32\KernelBase.dll
...
\Device\HarddiskVolume2\Windows\System32\version.dll
\Device\HarddiskVolume2\Windows\System32\winspool.drv
Figura 5 Get-ETW superior VMops script para impresión Top n procesos a las operaciones de memoria virtual más
<####################
# Get-ETW-Top-VMops
# \@brief Gets the top $num processes ranked by the number of virtual
memory events
####################>
function Get-ETW-Top-VMops ([Int] $num) {
begin {
$hold = @{}
}
process {
$xmldata = $_
# Get a list of the PIDs
$list = $xmldata | Get-ETW-PID-List
# Iterate through each PID
$eventxml = $xmldata | Get-ETW-PID-Events $list.Keys
foreach ($pd in $list.Keys) {
$vmops = 0
# Count the number of VM events
foreach ($e in $eventxml.$pd.Events.Event) {
[String] $type = $e.RenderingInfo.EventName.InnerText
[String] $opcode = $e.RenderingInfo.Opcode
if ($type -eq "PageFault") {
if ($opcode -eq "VirtualAlloc" –or
$opcode -eq "VirtualFree") {
$ vmops++
}
}
}
$hold.$pd = $vmops
}
}
end {
"{0,-20}|{1,-7}| VM Event Count" -f "Binar"," PID"
"--------------------------------------------------------"
$j = 0
foreach ($e in ($hold.GetEnumerator() | Sort Value -Descending)) {
if ($j -lt $num) {
$key = $e.Key
"{0,-20} ({1,-6} {2}" -f $list.$key,"$($e.Key))",$e.Value
} else {
return
}
$j++
}
}
}
Ejemplos de Analysis de sucesos del sistema operativo Core simple
En esta sección se presentan secuencias de comandos simples para demostrar unas cuantas técnicas básicas de Contabilidad en algunos de los eventos de sistema operativo introducidos anteriormente. Se utilizará secuencias de comandos de Windows PowerShell para simplificar, pero los algoritmos subyacentes pueden ser adoptados en aplicaciones para el procesamiento más eficaz. Una vez creado un volcado XML mediante la herramienta tracerpt, uno puede importar los eventos como objetos en Windows PowerShell con los comandos siguientes:
>$ xmldata = New-Object System.Xml.XmlDocument
>$ xmldata.Load (< xml archivo de volcado >)
La primera secuencia de Windows PowerShell de de figura 1 simplemente imprime todos los procesos en el archivo de registro buscando eventos de proceso. Actualiza una tabla hash con un par de id y nombre de proceso e imprime la tabla al final si se especifica la opción Print. De forma predeterminada, pasa junto a la matriz de pares de a una canalización para que otras secuencias de comandos pueden usar su salida. Tenga en cuenta que hemos omitido convencional tratamiento de argumentos, comentarios y comprobaciones de errores para simplificar las secuencias de comandos de ejemplo. Suponemos que también el proceso y los identificadores de subproceso no se reciclan durante la sesión de núcleo en esta secuencia de comandos, pero obtener reciclar en realidad. Códigos adicionales son necesarios para procesamiento correcto.
El resultado de esta secuencia de comandos, si el volcado de xml contiene eventos del proceso, es como se muestra en de figura 2. El objetivo de la secuencia de comandos siguiente es crear un estado básico de máquina y, dado un identificador de proceso, para imprimir el número de subprocesos y una lista de imágenes cargadas en ese proceso. Si se especifica las opciones – i – o – t, la secuencia de comandos imprime los nombres de cargadas de imágenes y los identificadores de subprocesos del proceso, en lugar de los recuentos de imágenes y subprocesos. de la figura 3 muestra el script Get-ETW PID información escrita para esta funcionalidad. Esta secuencia de comandos llama a otra secuencia de comandos denominado Get-ETW-PID-eventos (que se no se muestran aquí) que recoge los eventos relevantes para el identificador de proceso determinado.
Busca el proceso de Bloc de notas de de figura 2, se obtiene el siguiente resultado de la secuencia de comandos Get-ETW PID información. Figura 4 enumera todos los módulos cargados por notepad.exe.
Por último, vamos a imprimir una tabla con procesos n superiores con las operaciones más de memoria virtual. En esta secuencia de comandos denominado Get-ETW-superior-VMops, se muestra en de figura 5, podemos ejecutar Get-ETW-PID-List para construir una lista de identificadores de proceso. A continuación, hemos filtrar eventos por cada identificador de proceso y contar los eventos de la máquina virtual. Por último, nos ordenar e imprimir la tabla con procesos n superiores.
El resultado de esta secuencia de comandos con 10 procesos con las operaciones de memoria virtual de la mayoría de los se expresa en de figura 6. Observe que dos instancias de logman.exe hacia arriba en la tabla, una para iniciar y otro para detener la sesión de núcleo.
Figura 6 la salida de Get-ETW superior VMops
PS C:\tests> $xml | Get-ETW-Top-Vmops 10
Binary | PID | VM Event Count
--------------------------------------------------------
svchost.exe (536) 486
iexplore.exe (3184) 333
svchost.exe (1508) 206
logman.exe (2836) 98
svchost.exe (892) 37
sidebar.exe (3836) 37
logman.exe (1192) 19
svchost.exe (2052) 18
audiodg.exe (7048) 18
services.exe (480) 13
Mejorar la capacidad de herramienta
Windows 7 incluye cientos de proveedores de eventos procedentes de diversos componentes. En esta serie de artículo de dos partes, nos han presenta el conjunto de principales OS ETW eventos disponibles en Windows 7 y las técnicas de análisis que hemos utilizado durante muchos años. Eventos individuales indican determinadas actividades en el núcleo del sistema operativo, pero si se combinan mediante métodos de análisis contextual, pueden utilizarse para producir informes significativos que ofrecen perspectivas en patrones y anomalías en el uso de recursos. Además, somos conscientes de en el que resultó eficaz y cuidado de examen de un subconjunto de estos eventos en excelentes resultados en campos especializados de estudio de casos muy pocos. Las aplicaciones instrumentadas con ETW pueden beneficiarse incluso más precisa la correlación de aplicación y las actividades del sistema operativo;Por ejemplo, si una aplicación emite eventos que indican un comienzo y un fin de una actividad importante aplicación, principales OS eventos recopilados al mismo tiempo contiene precisa la información de uso de recursos del sistema operativo atribuir a esa actividad. Los desarrolladores de herramienta de administración y rendimiento pueden sacar partido de los eventos de sistema principales y diversas técnicas de análisis para mejorar su capacidad de herramienta que se beneficiará a su vez los trabajadores de TI. Los desarrolladores de aplicaciones puede diagnosticar problemas de aplicación mejor si este análisis se incorpora en sus entornos. Esperamos que nuestra serie de artículo de dos partes conducirá a la promoción de mayor calidad de software, prácticas de ingeniería de sonido y mejores experiencias de usuario.
Dr. Insung Park es un jefe de desarrollo para el Instrumental de Windows y el equipo de la plataforma de diagnóstico. Ha publicado una docena papeles en análisis de rendimiento, seguimiento de convocatoria, tecnología de instrumentación y programación metodología y soporte técnico. Su dirección de correo electrónico es de insungp@microsoft.com.
Alex Bendetov es un jefe de desarrollo para el Instrumental de Windows y el equipo de la plataforma de diagnóstico. Trabaja en el seguimiento de eventos para Windows y las tecnologías de contador de rendimiento. Puede ponerse en alexbe@microsoft.com de.