Downloads & Free Reading Options - Results

Objective: To facilitate C2 Architecture and Applications development in terms of a formal language for C2 based upon a C2RM; To derive the rules for analyzing and parsing C2 Products from Natural Language to Machine Language for use by C2 Applications; To leverage commercial representation and modeling languages such as the Unified Modeling Language (UML) and Extensible Markup Language (XML) and associated tools.

This memo presents a technique for using XML (Extensible Markup Language) as a source format for documents in the Internet-Drafts (I-Ds) and Request for Comments (RFC) series. This memo provides information for the Internet community.

This memo presents a technique for using XML (Extensible Markup Language) as a source format for documents in the Internet-Drafts (I-Ds) and Request for Comments (RFC) series. This memo provides information for the Internet community.

This memo presents a technique for using XML (Extensible Markup Language) as a source format for documents in the Internet-Drafts (I-Ds) and Request for Comments (RFC) series. This memo provides information for the Internet community.

This paper discusses the detailed design of an XML databinding framework for aircraft engine simulation. The framework provides an object interface to access and use engine data. while at the same time preserving the meaning of the original data. The Language independent representation of engine component data enables users to move around XML data using HTTP through disparate networks. The application of this framework is demonstrated via a web-based turbofan propulsion system simulation using the World Wide Web (WWW). A Java Servlet based web component architecture is used for rendering XML engine data into HTML format and dealing with input events from the user, which allows users to interact with simulation data from a web browser. The simulation data can also be saved to a local disk for archiving or to restart the simulation at a later time.

The AIAA Modeling and Simulation Technical Committee has worked for several years to develop a standard by which the information needed to develop physics-based models of aircraft can be specified. The purpose of this standard is to provide a well-defined set of information, definitions, data tables and axis systems so that cooperating organizations can transfer a model from one simulation facility to another with maximum efficiency. This paper proposes using an application of the eXtensible Markup Language (XML) to implement the AIAA simulation standard. The motivation and justification for using a standard such as XML is discussed. Necessary data elements to be supported are outlined. An example of an aerodynamic model as an XML file is given. This example includes definition of independent and dependent variables for function tables, definition of key variables used to define the model, and axis systems used. The final steps necessary for implementation of the standard are presented. Software to take an XML-defined model and import/export it to/from a given simulation facility is discussed, but not demonstrated. That would be the next step in final implementation of standards for physics-based aircraft dynamic models.

The primary goal of this thesis is to investigate the use of the eXtensible Markup Language (XML) as a network configuration language. Network configuration is a difficult and time- consuming task. Current network configuration solutions are based on proprietary configuration languages and parsers. XML is a platform-neutral data representation language and worldwide standard. It is potentially advantageous to use XML to configure networks, however, XML was not developed for network configuration. A new XML based configuration solution for the Server and Agent Active Network Management System (SAAM) is provided to marshal evidence that XML can be used effectively as a network configuration language.

The Chromium Projects Home Chromium ChromiumOS Quick links Report bugs Discuss Other sites Chromium Blog Google Chrome Extensions Except as otherwise  noted , the content of this page is licensed under a  Creative Commons Attribution 2.5 license , and examples are licensed under the  BSD License . Privacy Edit this page For Developers  >  How-Tos  > Debugging Chromium on Windows First see  get the code  for checkout and build instructions. Getting started You can use Visual Studio's built-in debugger or  WinDBG  to debug Chromium. You don't need to use the IDE to build in order to use the debugger: autoninja is used to build Chromium and most developers invoke it from a command prompt, and then open the IDE for debugging as necessary. To start debugging an already-built executable with Visual Studio just launch Visual Studio (2019 or higher) and select File-> Open-> Project/Solution (Ctrl+Shift+O) and select the executable of interest. This will create a solution with that executable as the 'project'. You can then launch the debugger with F5 or F11 or from the Debug menu. If you right-click on the executable in Solution Explorer and select properties then you can edit things such as the executable path, command-line arguments, and working directory. You can add additional executables to the solution by using File-> Add-> Existing Project and selecting another already-built executable. You can select which one to debug by right-clicking on one of them in Solution Explorer and selecting Set as Startup Project. When your solution file is customized to your taste you can save it to a directory such as out\solutions. Saving it there helps ensure that relative paths to source files, printed from build commands, will correctly identify the source files. The Tools menu can be used to add commands to do things like invoke autoninja to build Chrome, compile the selected source file, or other things. Visual Studio 2017 is not recommended for debugging of Chromium - use a newer version for best performance and stability. symbol_level=2  is the default on Windows and gives full debugging information with types, locals, globals, function names, and source/line information.  symbol_level=1  creates smaller PDBs with just function names, and source/line information - source-level debugging is still supported (new from June 2019), but local variables and type information are missing.  symbol_level=0  gives extremely limited debugging abilities, mostly just viewing call stacks when Chromium crashes. Browsing source code If you use a solution file generated by gn ( gn gen --ide=vs ) then Intellisense may help you navigate the code. If this doesn't work or if you use a solution created as above then you may want to install  VsChromium  to help navigate the code, as well as using  https://source.chromium.org . Profiles It's a good idea to use a different Chrome profile for your debugging. If you are debugging Google Chrome branded builds, or use a Chromium build as your primary browser, the profiles can collide so you can't run both at once, and your stable browser might see profile versions from the future (Google Chrome and Chromium use different profile directories by default so won't collide). Use the command-line option: --user-data-dir =C:\tmp\my_debug_profile (replace the path as necessary) Using the IDE, go to the  Debugging  tab of the properties of the chrome project, and set the  Command Arguments. Chrome debug log Enable Chrome debug logging to a file by passing  --enable-logging --v=1  command-line flags at startup. Debug builds place the  chrome_debug.log  file in the  out\Debug  directory. Release builds place the file in the top level of the user data Chromium app directory, which is OS-version-dependent. For more information, see  logging  and  user data directory  details. Symbol server If you are debugging official Google Chrome release builds, use the symbol server: https://chromium-browser-symsrv.commondatastorage.googleapis.com In Visual Studio, this goes in  Tools > Options  under  Debugging > Symbols . You should set up a local cache in a empty directory on your computer. In windbg you can add this to your symbol server search path with the command below, where C:\symbols is a local cache directory: .sympath+ SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Alternately, You can set the _NT_SYMBOL_PATH environment variable to include both the Microsoft and Google symbol servers - VS, windbg, and other tools should both respect this environment variable: _NT_SYMBOL_PATH =SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols ;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Note that symbol servers will let the debuggers download both the PE files (DLLs and EXEs) and the PDB files. Chrome often loads third party libraries and partial symbols for some of these are also public. For example: AMD : https://download.amd.com/dir/bin Nvidia : https://driver-symbols.nvidia.com/ Intel : https://software.intel.com/sites/downloads/symbols/ For example, for completeness, the following symbol server environment variable will resolve all of the above sources - but this is more than is normally needed: _NT_SYMBOL_PATH=SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com;SRV\*C:\symbols\*https://download.amd.com/dir/bin;SRV\*C:\symbols\*https://driver-symbols.nvidia.com/;SRV\*C:\symbols\*https://software.intel.com/sites/downloads/symbols/ Source indexing You should set up source indexing in your debugger ( .srcfix  in windbg, Tools-> Options-> Debugging-> General->  Enable source server support  in Visual Studio) so that the correct source files will automatically be downloaded based on information in the downloaded symbols. Additionally, you must have  python  in your  path  in order for the  command that fetches source files  to succeed; launching the debugger from the same environment as where you build Chromium is an easy way to ensure it's present. This is highly recommended when debugging released Google Chrome builds or looking at crash dumps. Having the correct version of the source files automatically show up saves significant time so you should definitely set this. Multi-process issues Chromium can be challenging to debug because of its  multi-process architecture . When you select  Run  in the debugger, only the main browser process will be debugged. The code that actually renders web pages (the Renderer) and the plugins will be in separate processes that's not (yet!) being debugged. The  ProcessExplorer  tool has a process tree view where you can see how these processes are related. You can also get the process IDs associated with each tab from the Chrome Task Manager (right-click on an empty area of the window title bar to open). Automatically attach to child processes There are two Visual Studio extensions that enable the debugger to automatically attach to all Chrome processes, so you can debug all of Chrome at once. Microsoft's  Child Process Debugging Power Tool  is a standalone extension for this, and  VsChromium  is another option that bundles many other additional features. In addition to installing one of these extensions, you  must  run Visual Studio as Administrator, or it will silently fail to attach to some of Chrome's child processes. Single-process mode One way to debug issues is to run Chromium in single-process mode. This will allow you to see the entire state of the program without extra work (although it will still have many threads). To use single-process mode, add the command-line flag --single-process This approach isn't perfect because some problems won't manifest themselves in this mode and some features don't work and worker threads are still spawned into new processes. Manually attaching to a child process You can attach to the running child processes with the debugger. Select  Tools > Attach to Process  and click the  chrome.exe  process you want to attach to. Before attaching, make sure you have selected only Native code when attaching to the process This is done by clicking Select... in the Attach to Process window and only checking Native. If you forget this, it may attempt to attach in "WebKit" mode to debug JavaScript, and you'll get an error message "An operation is not legal in the current state." You can now debug the two processes as if they were one. When you are debugging multiple processes, open the  Debug > Windows > Processes  window to switch between them. Sometimes you are debugging something that only happens on startup, and want to see the child process as soon as it starts. Use: --renderer-startup-dialog --no-sandbox You have to disable the sandbox or the dialog box will be prohibited from showing. When the dialog appears, visit Tools > Attach to Process and attach to the process showing the Renderer startup dialog. Now you're debugging in the renderer and can continue execution by pressing OK in the dialog. Startup dialogs also exist for other child process types:  --gpu-startup-dialog ,  --ppapi-startup-dialog ,  --utility-startup-dialog ,  --plugin-startup-dialog  (for NPAPI). For utilities, you can add a service type  --utility-startup-dialog=data_decoder.mojom.DataDecoderService . You can also try  the vs-chromium plug-in  to attach to the right processes. Semi-automatically attaching the debugger to child processes The following flags cause child processes to wait for 60 seconds in a busy loop for a debugger to attach to the process. Once either condition is true, it continues on; no exception is thrown. --wait-for-debugger-children [=filter] The filter, if provided, will fire only if it matches the  --type  parameter to the process. Values include  renderer ,  plugin  (for NPAPI),  ppapi ,  gpu-process , and  utility . When using this option, it may be helpful to limit the number of renderer processes spawned, using: --renderer-process-limit = 1 Image File Execution Options Using Image File Execution Options (IFEO) will not work because CreateProcess() returns the handle to the debugger process instead of the intended child process. There are also issues with the sandbox. Time travel debugging You can do  time travel debugging using WinDbg Preview  (must be installed from the Microsoft Store). This lets you execute a program forward and backwards. After capturing a trace, you can set breakpoints and step through code as normal, but also provides 'backwards' commands (g-, t-, p-) so that you can go back and forth through the execution. It is especially useful to set data breakpoints ( ba command ) and reverse continuing, so you can see when a certain variable was last changed to its current value. Chromium specifics: The type of injection the time travel tracer needs to perform is incompatible with the Chromium sandbox. In order to record a trace, you'll need to run with  --no-sandbox . Chromium cannot run elevated with Administrator privileges, so the "Launch executable (advance)" option won't work, you'll need to attach after the process has already launched via the checkbox in the bottom right. If you need to record startup-like things, you'll have to use --{browser,gpu,renderer,utility}-startup-dialog, then attach (and hope the relevant code hasn't executed before that point). JsDbg -- data structure visualization You can install  JsDbg as a plugin for WinDbg or Visual Studio . It interactively lets you look at data structures (such as the DOM tree, Accessibility tree, layout object tree, and others) in a web browser as you debug. See the  JsDbg site  for some screen shots and usage examples. This also works when examining memory dumps (though not minidumps), and also works together with time travel debugging. Visual Studio hints Debug visualizers Chrome's custom debug visualizers should be added to the pdb files and automatically picked up by Visual Studio. The definitions are in  //tools/win/DebugVisualizers  if you need to modify them (the BUILD.gn file there has additional instructions). Don't step into trivial functions The debugger can be configured to automatically not step into functions based on regular expression. Edit  default.natstepfilter  in the following directory: For Visual Studio 2015:  C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2015\Visualizers  (for the current user only) For Visual Studio 2017 Pro:  C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2017\Visualizers  (for the current user only) Add regular expressions of functions to not step into. Remember to regex-escape  and  XML-escape them, e.g. < for < and \. for a literal dot. Example: < Function > < Name > operator new </ Name > < Action > NoStepInto </ Action > </ Function > < Function > < Name > operator delete </ Name > < Action > NoStepInto </ Action > </ Function > <!-- Skip everything in std --> < Function > < Name > std::.* </ Name > < Action > NoStepInto </ Action > </ Function > <!-- all methods on WebKit OwnPtr and variants, ... WTF::*Ptr<*>::* --> < Function > < Name > WTF::.*Ptr<.*>::.* </ Name > < Action > NoStepInto </ Action > </ Function > This file is read at start of a debugging session (F5), so you don't need to restart Visual Studio after changing it. More info:  Microsoft email thread V8 and Chromium V8 supports many command-line flags that are useful for debugging. V8 command-line flags can be set via the Chromium command-line flag --js-flags; for instance: chrome.exe --js-flags= "--trace_exception --heap_stats" Note that some V8 command-line flags exist only in the debug build of V8. For a list of all V8 flags try: chrome.exe --js-flags= "--help" Graphics debugging GPU Acceleration of rendering can be more easily debugged with tools. See: Graphics Debugging in Visual Studio 2013 Graphical debugging with NVIDIA NSight Debugging on another machine Sometimes it's useful to debug installation and execution on a machine other than your primary build box. To run the installer on said other machine, first build the mini_installer target on your main build machine (e.g., autoninja -C out\Debug mini_installer). Next, on the debug machine: Make the build machine's build volume available on the debug machine either by mounting it locally (e.g., Z:\) or by crafting a UNC path to it (e.g., \\builder\src) Open up a command prompt and change to a local disk Run src\tools\win\ copy-installer.bat  in the remote checkout by way of the mount (e.g., Z:\PATHTOCHECKOUT\src\...) or UNC path (e.g., \\builder\src\...). This will copy the installer, DLLs, and PDBs into your debug machine's C:\out or C:\build (depending on if you're rocking the component=shared_library build or not) Run  C:\out\Debug\mini_installer.exe  with the flags of your choice to install Chrome. This can take some time, especially on a slow machine. Watch the Task Manager and wait until mini_installer.exe exits before trying to launch Chrome (by way of the shortcut(s) created by the installer) For extra pleasure, add C:\out\Debug to your _NT_SYMBOL_PATH environment variable Consider reading the documentation at the top of copy-installer.bat to see how you can run it. It tries to be smart and copy the right things, but you may need to be explicit (e.g., "copy-installer.bat out Debug"). It is safe to re-run the script to copy only modified files (after a rebuild, for example). You can also use the zip action of the isolate scripts (tools\mb\mb.py) to package all the files for a target into a single zip file, for example: python tools\mb\mb.py zip out/Release base_unittests base_unittests. zip Finding all memory allocations It is possible to use Heap Snapshots to get call stacks on all outstanding allocations that use the OS heap. This works particularly well if heap snapshots are started as soon as the Chrome browser process is created, but before it starts running. Details can be found in  this batch file . However, with  PartitionAlloc Everywhere  most Chromium allocations no longer use the Windows heap so this will only find a subset of allocations, mostly from OS DLLs. Find memory leaks Note: as with Heap Snapshots the utility of UMDH is greatly reduced now because PartitionAlloc Everywhere has mostly replaced the Windows heap. The Windows heap manager has a really useful debug flag, where it can be asked to capture and store a stack trace with every allocation. The tool to scrape these stack traces out of processes is UMDH, which comes with  WinDbg . UMDH is great. It will capture a snapshot of the heap state as many times as you like, and it'll do it fairly quickly. You then run it again against either a single snapshot, or a pair of snapshots, at which time it'll symbolize the stack traces and aggregate usage up to unique stack traces. Turning on the user stack trace database for chrome.exe with gflags.exe makes it run unbearably slowly; however, turning on the user stack trace database on for the browser alone is just fine. While it's possible to turn on the user stack database with the "!gflag" debugging extension, it's too late to do this by the time the initial debugger breakpoint hits. The only reasonable way to do this is to Launch GFlags.exe, Enable the user stack trace database (per image below), Launch Chrome under the debugger. Set a breakpont when chrome.dll loads with "sxe ld chrome.dll". Step up, to allow Chrome.dll to initialize. Disable the stack trace database in GFlags.exe. Continue chrome, optionally detaching the debugger. GFlags.exe settings for user mode stack trace database. If you then ever suffer a browser memory leak, you can snarf a dump of the process with umdh - p :<my browser pid> > chrome-browser-leak-umdh-dump.txt which can then typically be "trivially" analyzed to find the culprit. Miscellaneous Note that by default Application Verifier only works with non-official builds of Chromium. To use Application Verifier on official builds you need to add --disable-features=RendererCodeIntegrity to avoid sandbox crashes in renderer processes. See  crbug.com/1004989  for details. See also  this page . Application Verifier  is a free tool from Microsoft (available as part of the Windows SDK) that can be used to flush out programming errors. Starting with M68 Application Verifier can be enabled for chrome.exe without needing to disable the sandbox. After adding chrome.exe to the list of applications to be stressed you need to expand the list of Basics checks and disable the  Leak  checks. You may also need to disable  Handles  and  Locks  checks depending on your graphics driver and specific Chrome version, but the eventual goal is to have Chrome run with  Handles  and  Locks  checks enabled. When bugs are found Chrome will trigger a breakpoint so running all Chrome processes under a debugger is recommended. Chrome will run much more slowly because Application Verifier puts every heap allocation on a separate page. Note that with PartitionAlloc Everywhere most Chromium allocations don't actually go through the Windows heap and are therefore unaffected by Application Verifier. You can check the undocumented 'Cuzz' checkbox in Application Verifier to get the Windows thread scheduler to add some extra randomness in order to help expose race conditions in your code. To put a breakpoint on CreateFile(), add this break point: {,,kernel32.dll}_CreateFileW@28 {,,kernel32.dll} specifies the DLL (context operator). _ prefix means extern "C". @28 postfix means _stdcall with the stack pop at the end of the function. i.e. the number of arguments in BYTES. You can use  DebugView  from SysInternals or  sawbuck  to view LOG() messages that normally go to stderr on POSIX.

The Chromium Projects Home Chromium ChromiumOS Quick links Report bugs Discuss Other sites Chromium Blog Google Chrome Extensions Except as otherwise  noted , the content of this page is licensed under a  Creative Commons Attribution 2.5 license , and examples are licensed under the  BSD License . Privacy Edit this page For Developers  >  How-Tos  > Debugging Chromium on Windows First see  get the code  for checkout and build instructions. Getting started You can use Visual Studio's built-in debugger or  WinDBG  to debug Chromium. You don't need to use the IDE to build in order to use the debugger: autoninja is used to build Chromium and most developers invoke it from a command prompt, and then open the IDE for debugging as necessary. To start debugging an already-built executable with Visual Studio just launch Visual Studio (2019 or higher) and select File-> Open-> Project/Solution (Ctrl+Shift+O) and select the executable of interest. This will create a solution with that executable as the 'project'. You can then launch the debugger with F5 or F11 or from the Debug menu. If you right-click on the executable in Solution Explorer and select properties then you can edit things such as the executable path, command-line arguments, and working directory. You can add additional executables to the solution by using File-> Add-> Existing Project and selecting another already-built executable. You can select which one to debug by right-clicking on one of them in Solution Explorer and selecting Set as Startup Project. When your solution file is customized to your taste you can save it to a directory such as out\solutions. Saving it there helps ensure that relative paths to source files, printed from build commands, will correctly identify the source files. The Tools menu can be used to add commands to do things like invoke autoninja to build Chrome, compile the selected source file, or other things. Visual Studio 2017 is not recommended for debugging of Chromium - use a newer version for best performance and stability. symbol_level=2  is the default on Windows and gives full debugging information with types, locals, globals, function names, and source/line information.  symbol_level=1  creates smaller PDBs with just function names, and source/line information - source-level debugging is still supported (new from June 2019), but local variables and type information are missing.  symbol_level=0  gives extremely limited debugging abilities, mostly just viewing call stacks when Chromium crashes. Browsing source code If you use a solution file generated by gn ( gn gen --ide=vs ) then Intellisense may help you navigate the code. If this doesn't work or if you use a solution created as above then you may want to install  VsChromium  to help navigate the code, as well as using  https://source.chromium.org . Profiles It's a good idea to use a different Chrome profile for your debugging. If you are debugging Google Chrome branded builds, or use a Chromium build as your primary browser, the profiles can collide so you can't run both at once, and your stable browser might see profile versions from the future (Google Chrome and Chromium use different profile directories by default so won't collide). Use the command-line option: --user-data-dir =C:\tmp\my_debug_profile (replace the path as necessary) Using the IDE, go to the  Debugging  tab of the properties of the chrome project, and set the  Command Arguments. Chrome debug log Enable Chrome debug logging to a file by passing  --enable-logging --v=1  command-line flags at startup. Debug builds place the  chrome_debug.log  file in the  out\Debug  directory. Release builds place the file in the top level of the user data Chromium app directory, which is OS-version-dependent. For more information, see  logging  and  user data directory  details. Symbol server If you are debugging official Google Chrome release builds, use the symbol server: https://chromium-browser-symsrv.commondatastorage.googleapis.com In Visual Studio, this goes in  Tools > Options  under  Debugging > Symbols . You should set up a local cache in a empty directory on your computer. In windbg you can add this to your symbol server search path with the command below, where C:\symbols is a local cache directory: .sympath+ SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Alternately, You can set the _NT_SYMBOL_PATH environment variable to include both the Microsoft and Google symbol servers - VS, windbg, and other tools should both respect this environment variable: _NT_SYMBOL_PATH =SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols ;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Note that symbol servers will let the debuggers download both the PE files (DLLs and EXEs) and the PDB files. Chrome often loads third party libraries and partial symbols for some of these are also public. For example: AMD : https://download.amd.com/dir/bin Nvidia : https://driver-symbols.nvidia.com/ Intel : https://software.intel.com/sites/downloads/symbols/ For example, for completeness, the following symbol server environment variable will resolve all of the above sources - but this is more than is normally needed: _NT_SYMBOL_PATH=SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com;SRV\*C:\symbols\*https://download.amd.com/dir/bin;SRV\*C:\symbols\*https://driver-symbols.nvidia.com/;SRV\*C:\symbols\*https://software.intel.com/sites/downloads/symbols/ Source indexing You should set up source indexing in your debugger ( .srcfix  in windbg, Tools-> Options-> Debugging-> General->  Enable source server support  in Visual Studio) so that the correct source files will automatically be downloaded based on information in the downloaded symbols. Additionally, you must have  python  in your  path  in order for the  command that fetches source files  to succeed; launching the debugger from the same environment as where you build Chromium is an easy way to ensure it's present. This is highly recommended when debugging released Google Chrome builds or looking at crash dumps. Having the correct version of the source files automatically show up saves significant time so you should definitely set this. Multi-process issues Chromium can be challenging to debug because of its  multi-process architecture . When you select  Run  in the debugger, only the main browser process will be debugged. The code that actually renders web pages (the Renderer) and the plugins will be in separate processes that's not (yet!) being debugged. The  ProcessExplorer  tool has a process tree view where you can see how these processes are related. You can also get the process IDs associated with each tab from the Chrome Task Manager (right-click on an empty area of the window title bar to open). Automatically attach to child processes There are two Visual Studio extensions that enable the debugger to automatically attach to all Chrome processes, so you can debug all of Chrome at once. Microsoft's  Child Process Debugging Power Tool  is a standalone extension for this, and  VsChromium  is another option that bundles many other additional features. In addition to installing one of these extensions, you  must  run Visual Studio as Administrator, or it will silently fail to attach to some of Chrome's child processes. Single-process mode One way to debug issues is to run Chromium in single-process mode. This will allow you to see the entire state of the program without extra work (although it will still have many threads). To use single-process mode, add the command-line flag --single-process This approach isn't perfect because some problems won't manifest themselves in this mode and some features don't work and worker threads are still spawned into new processes. Manually attaching to a child process You can attach to the running child processes with the debugger. Select  Tools > Attach to Process  and click the  chrome.exe  process you want to attach to. Before attaching, make sure you have selected only Native code when attaching to the process This is done by clicking Select... in the Attach to Process window and only checking Native. If you forget this, it may attempt to attach in "WebKit" mode to debug JavaScript, and you'll get an error message "An operation is not legal in the current state." You can now debug the two processes as if they were one. When you are debugging multiple processes, open the  Debug > Windows > Processes  window to switch between them. Sometimes you are debugging something that only happens on startup, and want to see the child process as soon as it starts. Use: --renderer-startup-dialog --no-sandbox You have to disable the sandbox or the dialog box will be prohibited from showing. When the dialog appears, visit Tools > Attach to Process and attach to the process showing the Renderer startup dialog. Now you're debugging in the renderer and can continue execution by pressing OK in the dialog. Startup dialogs also exist for other child process types:  --gpu-startup-dialog ,  --ppapi-startup-dialog ,  --utility-startup-dialog ,  --plugin-startup-dialog  (for NPAPI). For utilities, you can add a service type  --utility-startup-dialog=data_decoder.mojom.DataDecoderService . You can also try  the vs-chromium plug-in  to attach to the right processes. Semi-automatically attaching the debugger to child processes The following flags cause child processes to wait for 60 seconds in a busy loop for a debugger to attach to the process. Once either condition is true, it continues on; no exception is thrown. --wait-for-debugger-children [=filter] The filter, if provided, will fire only if it matches the  --type  parameter to the process. Values include  renderer ,  plugin  (for NPAPI),  ppapi ,  gpu-process , and  utility . When using this option, it may be helpful to limit the number of renderer processes spawned, using: --renderer-process-limit = 1 Image File Execution Options Using Image File Execution Options (IFEO) will not work because CreateProcess() returns the handle to the debugger process instead of the intended child process. There are also issues with the sandbox. Time travel debugging You can do  time travel debugging using WinDbg Preview  (must be installed from the Microsoft Store). This lets you execute a program forward and backwards. After capturing a trace, you can set breakpoints and step through code as normal, but also provides 'backwards' commands (g-, t-, p-) so that you can go back and forth through the execution. It is especially useful to set data breakpoints ( ba command ) and reverse continuing, so you can see when a certain variable was last changed to its current value. Chromium specifics: The type of injection the time travel tracer needs to perform is incompatible with the Chromium sandbox. In order to record a trace, you'll need to run with  --no-sandbox . Chromium cannot run elevated with Administrator privileges, so the "Launch executable (advance)" option won't work, you'll need to attach after the process has already launched via the checkbox in the bottom right. If you need to record startup-like things, you'll have to use --{browser,gpu,renderer,utility}-startup-dialog, then attach (and hope the relevant code hasn't executed before that point). JsDbg -- data structure visualization You can install  JsDbg as a plugin for WinDbg or Visual Studio . It interactively lets you look at data structures (such as the DOM tree, Accessibility tree, layout object tree, and others) in a web browser as you debug. See the  JsDbg site  for some screen shots and usage examples. This also works when examining memory dumps (though not minidumps), and also works together with time travel debugging. Visual Studio hints Debug visualizers Chrome's custom debug visualizers should be added to the pdb files and automatically picked up by Visual Studio. The definitions are in  //tools/win/DebugVisualizers  if you need to modify them (the BUILD.gn file there has additional instructions). Don't step into trivial functions The debugger can be configured to automatically not step into functions based on regular expression. Edit  default.natstepfilter  in the following directory: For Visual Studio 2015:  C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2015\Visualizers  (for the current user only) For Visual Studio 2017 Pro:  C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2017\Visualizers  (for the current user only) Add regular expressions of functions to not step into. Remember to regex-escape  and  XML-escape them, e.g. < for < and \. for a literal dot. Example: < Function > < Name > operator new </ Name > < Action > NoStepInto </ Action > </ Function > < Function > < Name > operator delete </ Name > < Action > NoStepInto </ Action > </ Function > <!-- Skip everything in std --> < Function > < Name > std::.* </ Name > < Action > NoStepInto </ Action > </ Function > <!-- all methods on WebKit OwnPtr and variants, ... WTF::*Ptr<*>::* --> < Function > < Name > WTF::.*Ptr<.*>::.* </ Name > < Action > NoStepInto </ Action > </ Function > This file is read at start of a debugging session (F5), so you don't need to restart Visual Studio after changing it. More info:  Microsoft email thread V8 and Chromium V8 supports many command-line flags that are useful for debugging. V8 command-line flags can be set via the Chromium command-line flag --js-flags; for instance: chrome.exe --js-flags= "--trace_exception --heap_stats" Note that some V8 command-line flags exist only in the debug build of V8. For a list of all V8 flags try: chrome.exe --js-flags= "--help" Graphics debugging GPU Acceleration of rendering can be more easily debugged with tools. See: Graphics Debugging in Visual Studio 2013 Graphical debugging with NVIDIA NSight Debugging on another machine Sometimes it's useful to debug installation and execution on a machine other than your primary build box. To run the installer on said other machine, first build the mini_installer target on your main build machine (e.g., autoninja -C out\Debug mini_installer). Next, on the debug machine: Make the build machine's build volume available on the debug machine either by mounting it locally (e.g., Z:\) or by crafting a UNC path to it (e.g., \\builder\src) Open up a command prompt and change to a local disk Run src\tools\win\ copy-installer.bat  in the remote checkout by way of the mount (e.g., Z:\PATHTOCHECKOUT\src\...) or UNC path (e.g., \\builder\src\...). This will copy the installer, DLLs, and PDBs into your debug machine's C:\out or C:\build (depending on if you're rocking the component=shared_library build or not) Run  C:\out\Debug\mini_installer.exe  with the flags of your choice to install Chrome. This can take some time, especially on a slow machine. Watch the Task Manager and wait until mini_installer.exe exits before trying to launch Chrome (by way of the shortcut(s) created by the installer) For extra pleasure, add C:\out\Debug to your _NT_SYMBOL_PATH environment variable Consider reading the documentation at the top of copy-installer.bat to see how you can run it. It tries to be smart and copy the right things, but you may need to be explicit (e.g., "copy-installer.bat out Debug"). It is safe to re-run the script to copy only modified files (after a rebuild, for example). You can also use the zip action of the isolate scripts (tools\mb\mb.py) to package all the files for a target into a single zip file, for example: python tools\mb\mb.py zip out/Release base_unittests base_unittests. zip Finding all memory allocations It is possible to use Heap Snapshots to get call stacks on all outstanding allocations that use the OS heap. This works particularly well if heap snapshots are started as soon as the Chrome browser process is created, but before it starts running. Details can be found in  this batch file . However, with  PartitionAlloc Everywhere  most Chromium allocations no longer use the Windows heap so this will only find a subset of allocations, mostly from OS DLLs. Find memory leaks Note: as with Heap Snapshots the utility of UMDH is greatly reduced now because PartitionAlloc Everywhere has mostly replaced the Windows heap. The Windows heap manager has a really useful debug flag, where it can be asked to capture and store a stack trace with every allocation. The tool to scrape these stack traces out of processes is UMDH, which comes with  WinDbg . UMDH is great. It will capture a snapshot of the heap state as many times as you like, and it'll do it fairly quickly. You then run it again against either a single snapshot, or a pair of snapshots, at which time it'll symbolize the stack traces and aggregate usage up to unique stack traces. Turning on the user stack trace database for chrome.exe with gflags.exe makes it run unbearably slowly; however, turning on the user stack trace database on for the browser alone is just fine. While it's possible to turn on the user stack database with the "!gflag" debugging extension, it's too late to do this by the time the initial debugger breakpoint hits. The only reasonable way to do this is to Launch GFlags.exe, Enable the user stack trace database (per image below), Launch Chrome under the debugger. Set a breakpont when chrome.dll loads with "sxe ld chrome.dll". Step up, to allow Chrome.dll to initialize. Disable the stack trace database in GFlags.exe. Continue chrome, optionally detaching the debugger. GFlags.exe settings for user mode stack trace database. If you then ever suffer a browser memory leak, you can snarf a dump of the process with umdh - p :<my browser pid> > chrome-browser-leak-umdh-dump.txt which can then typically be "trivially" analyzed to find the culprit. Miscellaneous Note that by default Application Verifier only works with non-official builds of Chromium. To use Application Verifier on official builds you need to add --disable-features=RendererCodeIntegrity to avoid sandbox crashes in renderer processes. See  crbug.com/1004989  for details. See also  this page . Application Verifier  is a free tool from Microsoft (available as part of the Windows SDK) that can be used to flush out programming errors. Starting with M68 Application Verifier can be enabled for chrome.exe without needing to disable the sandbox. After adding chrome.exe to the list of applications to be stressed you need to expand the list of Basics checks and disable the  Leak  checks. You may also need to disable  Handles  and  Locks  checks depending on your graphics driver and specific Chrome version, but the eventual goal is to have Chrome run with  Handles  and  Locks  checks enabled. When bugs are found Chrome will trigger a breakpoint so running all Chrome processes under a debugger is recommended. Chrome will run much more slowly because Application Verifier puts every heap allocation on a separate page. Note that with PartitionAlloc Everywhere most Chromium allocations don't actually go through the Windows heap and are therefore unaffected by Application Verifier. You can check the undocumented 'Cuzz' checkbox in Application Verifier to get the Windows thread scheduler to add some extra randomness in order to help expose race conditions in your code. To put a breakpoint on CreateFile(), add this break point: {,,kernel32.dll}_CreateFileW@28 {,,kernel32.dll} specifies the DLL (context operator). _ prefix means extern "C". @28 postfix means _stdcall with the stack pop at the end of the function. i.e. the number of arguments in BYTES. You can use  DebugView  from SysInternals or  sawbuck  to view LOG() messages that normally go to stderr on POSIX.

The Chromium Projects Home Chromium ChromiumOS Quick links Report bugs Discuss Other sites Chromium Blog Google Chrome Extensions Except as otherwise  noted , the content of this page is licensed under a  Creative Commons Attribution 2.5 license , and examples are licensed under the  BSD License . Privacy Edit this page For Developers  >  How-Tos  > Debugging Chromium on Windows First see  get the code  for checkout and build instructions. Getting started You can use Visual Studio's built-in debugger or  WinDBG  to debug Chromium. You don't need to use the IDE to build in order to use the debugger: autoninja is used to build Chromium and most developers invoke it from a command prompt, and then open the IDE for debugging as necessary. To start debugging an already-built executable with Visual Studio just launch Visual Studio (2019 or higher) and select File-> Open-> Project/Solution (Ctrl+Shift+O) and select the executable of interest. This will create a solution with that executable as the 'project'. You can then launch the debugger with F5 or F11 or from the Debug menu. If you right-click on the executable in Solution Explorer and select properties then you can edit things such as the executable path, command-line arguments, and working directory. You can add additional executables to the solution by using File-> Add-> Existing Project and selecting another already-built executable. You can select which one to debug by right-clicking on one of them in Solution Explorer and selecting Set as Startup Project. When your solution file is customized to your taste you can save it to a directory such as out\solutions. Saving it there helps ensure that relative paths to source files, printed from build commands, will correctly identify the source files. The Tools menu can be used to add commands to do things like invoke autoninja to build Chrome, compile the selected source file, or other things. Visual Studio 2017 is not recommended for debugging of Chromium - use a newer version for best performance and stability. symbol_level=2  is the default on Windows and gives full debugging information with types, locals, globals, function names, and source/line information.  symbol_level=1  creates smaller PDBs with just function names, and source/line information - source-level debugging is still supported (new from June 2019), but local variables and type information are missing.  symbol_level=0  gives extremely limited debugging abilities, mostly just viewing call stacks when Chromium crashes. Browsing source code If you use a solution file generated by gn ( gn gen --ide=vs ) then Intellisense may help you navigate the code. If this doesn't work or if you use a solution created as above then you may want to install  VsChromium  to help navigate the code, as well as using  https://source.chromium.org . Profiles It's a good idea to use a different Chrome profile for your debugging. If you are debugging Google Chrome branded builds, or use a Chromium build as your primary browser, the profiles can collide so you can't run both at once, and your stable browser might see profile versions from the future (Google Chrome and Chromium use different profile directories by default so won't collide). Use the command-line option: --user-data-dir =C:\tmp\my_debug_profile (replace the path as necessary) Using the IDE, go to the  Debugging  tab of the properties of the chrome project, and set the  Command Arguments. Chrome debug log Enable Chrome debug logging to a file by passing  --enable-logging --v=1  command-line flags at startup. Debug builds place the  chrome_debug.log  file in the  out\Debug  directory. Release builds place the file in the top level of the user data Chromium app directory, which is OS-version-dependent. For more information, see  logging  and  user data directory  details. Symbol server If you are debugging official Google Chrome release builds, use the symbol server: https://chromium-browser-symsrv.commondatastorage.googleapis.com In Visual Studio, this goes in  Tools > Options  under  Debugging > Symbols . You should set up a local cache in a empty directory on your computer. In windbg you can add this to your symbol server search path with the command below, where C:\symbols is a local cache directory: .sympath+ SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Alternately, You can set the _NT_SYMBOL_PATH environment variable to include both the Microsoft and Google symbol servers - VS, windbg, and other tools should both respect this environment variable: _NT_SYMBOL_PATH =SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols ;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com Note that symbol servers will let the debuggers download both the PE files (DLLs and EXEs) and the PDB files. Chrome often loads third party libraries and partial symbols for some of these are also public. For example: AMD : https://download.amd.com/dir/bin Nvidia : https://driver-symbols.nvidia.com/ Intel : https://software.intel.com/sites/downloads/symbols/ For example, for completeness, the following symbol server environment variable will resolve all of the above sources - but this is more than is normally needed: _NT_SYMBOL_PATH=SRV\*C:\symbols\*https://msdl.microsoft.com/download/symbols;SRV\*C:\symbols\*https://chromium-browser-symsrv.commondatastorage.googleapis.com;SRV\*C:\symbols\*https://download.amd.com/dir/bin;SRV\*C:\symbols\*https://driver-symbols.nvidia.com/;SRV\*C:\symbols\*https://software.intel.com/sites/downloads/symbols/ Source indexing You should set up source indexing in your debugger ( .srcfix  in windbg, Tools-> Options-> Debugging-> General->  Enable source server support  in Visual Studio) so that the correct source files will automatically be downloaded based on information in the downloaded symbols. Additionally, you must have  python  in your  path  in order for the  command that fetches source files  to succeed; launching the debugger from the same environment as where you build Chromium is an easy way to ensure it's present. This is highly recommended when debugging released Google Chrome builds or looking at crash dumps. Having the correct version of the source files automatically show up saves significant time so you should definitely set this. Multi-process issues Chromium can be challenging to debug because of its  multi-process architecture . When you select  Run  in the debugger, only the main browser process will be debugged. The code that actually renders web pages (the Renderer) and the plugins will be in separate processes that's not (yet!) being debugged. The  ProcessExplorer  tool has a process tree view where you can see how these processes are related. You can also get the process IDs associated with each tab from the Chrome Task Manager (right-click on an empty area of the window title bar to open). Automatically attach to child processes There are two Visual Studio extensions that enable the debugger to automatically attach to all Chrome processes, so you can debug all of Chrome at once. Microsoft's  Child Process Debugging Power Tool  is a standalone extension for this, and  VsChromium  is another option that bundles many other additional features. In addition to installing one of these extensions, you  must  run Visual Studio as Administrator, or it will silently fail to attach to some of Chrome's child processes. Single-process mode One way to debug issues is to run Chromium in single-process mode. This will allow you to see the entire state of the program without extra work (although it will still have many threads). To use single-process mode, add the command-line flag --single-process This approach isn't perfect because some problems won't manifest themselves in this mode and some features don't work and worker threads are still spawned into new processes. Manually attaching to a child process You can attach to the running child processes with the debugger. Select  Tools > Attach to Process  and click the  chrome.exe  process you want to attach to. Before attaching, make sure you have selected only Native code when attaching to the process This is done by clicking Select... in the Attach to Process window and only checking Native. If you forget this, it may attempt to attach in "WebKit" mode to debug JavaScript, and you'll get an error message "An operation is not legal in the current state." You can now debug the two processes as if they were one. When you are debugging multiple processes, open the  Debug > Windows > Processes  window to switch between them. Sometimes you are debugging something that only happens on startup, and want to see the child process as soon as it starts. Use: --renderer-startup-dialog --no-sandbox You have to disable the sandbox or the dialog box will be prohibited from showing. When the dialog appears, visit Tools > Attach to Process and attach to the process showing the Renderer startup dialog. Now you're debugging in the renderer and can continue execution by pressing OK in the dialog. Startup dialogs also exist for other child process types:  --gpu-startup-dialog ,  --ppapi-startup-dialog ,  --utility-startup-dialog ,  --plugin-startup-dialog  (for NPAPI). For utilities, you can add a service type  --utility-startup-dialog=data_decoder.mojom.DataDecoderService . You can also try  the vs-chromium plug-in  to attach to the right processes. Semi-automatically attaching the debugger to child processes The following flags cause child processes to wait for 60 seconds in a busy loop for a debugger to attach to the process. Once either condition is true, it continues on; no exception is thrown. --wait-for-debugger-children [=filter] The filter, if provided, will fire only if it matches the  --type  parameter to the process. Values include  renderer ,  plugin  (for NPAPI),  ppapi ,  gpu-process , and  utility . When using this option, it may be helpful to limit the number of renderer processes spawned, using: --renderer-process-limit = 1 Image File Execution Options Using Image File Execution Options (IFEO) will not work because CreateProcess() returns the handle to the debugger process instead of the intended child process. There are also issues with the sandbox. Time travel debugging You can do  time travel debugging using WinDbg Preview  (must be installed from the Microsoft Store). This lets you execute a program forward and backwards. After capturing a trace, you can set breakpoints and step through code as normal, but also provides 'backwards' commands (g-, t-, p-) so that you can go back and forth through the execution. It is especially useful to set data breakpoints ( ba command ) and reverse continuing, so you can see when a certain variable was last changed to its current value. Chromium specifics: The type of injection the time travel tracer needs to perform is incompatible with the Chromium sandbox. In order to record a trace, you'll need to run with  --no-sandbox . Chromium cannot run elevated with Administrator privileges, so the "Launch executable (advance)" option won't work, you'll need to attach after the process has already launched via the checkbox in the bottom right. If you need to record startup-like things, you'll have to use --{browser,gpu,renderer,utility}-startup-dialog, then attach (and hope the relevant code hasn't executed before that point). JsDbg -- data structure visualization You can install  JsDbg as a plugin for WinDbg or Visual Studio . It interactively lets you look at data structures (such as the DOM tree, Accessibility tree, layout object tree, and others) in a web browser as you debug. See the  JsDbg site  for some screen shots and usage examples. This also works when examining memory dumps (though not minidumps), and also works together with time travel debugging. Visual Studio hints Debug visualizers Chrome's custom debug visualizers should be added to the pdb files and automatically picked up by Visual Studio. The definitions are in  //tools/win/DebugVisualizers  if you need to modify them (the BUILD.gn file there has additional instructions). Don't step into trivial functions The debugger can be configured to automatically not step into functions based on regular expression. Edit  default.natstepfilter  in the following directory: For Visual Studio 2015:  C:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2015\Visualizers  (for the current user only) For Visual Studio 2017 Pro:  C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Packages\Debugger\Visualizers  (for all users) or  %USERPROFILE%\My Documents\Visual Studio 2017\Visualizers  (for the current user only) Add regular expressions of functions to not step into. Remember to regex-escape  and  XML-escape them, e.g. < for < and \. for a literal dot. Example: < Function > < Name > operator new </ Name > < Action > NoStepInto </ Action > </ Function > < Function > < Name > operator delete </ Name > < Action > NoStepInto </ Action > </ Function > <!-- Skip everything in std --> < Function > < Name > std::.* </ Name > < Action > NoStepInto </ Action > </ Function > <!-- all methods on WebKit OwnPtr and variants, ... WTF::*Ptr<*>::* --> < Function > < Name > WTF::.*Ptr<.*>::.* </ Name > < Action > NoStepInto </ Action > </ Function > This file is read at start of a debugging session (F5), so you don't need to restart Visual Studio after changing it. More info:  Microsoft email thread V8 and Chromium V8 supports many command-line flags that are useful for debugging. V8 command-line flags can be set via the Chromium command-line flag --js-flags; for instance: chrome.exe --js-flags= "--trace_exception --heap_stats" Note that some V8 command-line flags exist only in the debug build of V8. For a list of all V8 flags try: chrome.exe --js-flags= "--help" Graphics debugging GPU Acceleration of rendering can be more easily debugged with tools. See: Graphics Debugging in Visual Studio 2013 Graphical debugging with NVIDIA NSight Debugging on another machine Sometimes it's useful to debug installation and execution on a machine other than your primary build box. To run the installer on said other machine, first build the mini_installer target on your main build machine (e.g., autoninja -C out\Debug mini_installer). Next, on the debug machine: Make the build machine's build volume available on the debug machine either by mounting it locally (e.g., Z:\) or by crafting a UNC path to it (e.g., \\builder\src) Open up a command prompt and change to a local disk Run src\tools\win\ copy-installer.bat  in the remote checkout by way of the mount (e.g., Z:\PATHTOCHECKOUT\src\...) or UNC path (e.g., \\builder\src\...). This will copy the installer, DLLs, and PDBs into your debug machine's C:\out or C:\build (depending on if you're rocking the component=shared_library build or not) Run  C:\out\Debug\mini_installer.exe  with the flags of your choice to install Chrome. This can take some time, especially on a slow machine. Watch the Task Manager and wait until mini_installer.exe exits before trying to launch Chrome (by way of the shortcut(s) created by the installer) For extra pleasure, add C:\out\Debug to your _NT_SYMBOL_PATH environment variable Consider reading the documentation at the top of copy-installer.bat to see how you can run it. It tries to be smart and copy the right things, but you may need to be explicit (e.g., "copy-installer.bat out Debug"). It is safe to re-run the script to copy only modified files (after a rebuild, for example). You can also use the zip action of the isolate scripts (tools\mb\mb.py) to package all the files for a target into a single zip file, for example: python tools\mb\mb.py zip out/Release base_unittests base_unittests. zip Finding all memory allocations It is possible to use Heap Snapshots to get call stacks on all outstanding allocations that use the OS heap. This works particularly well if heap snapshots are started as soon as the Chrome browser process is created, but before it starts running. Details can be found in  this batch file . However, with  PartitionAlloc Everywhere  most Chromium allocations no longer use the Windows heap so this will only find a subset of allocations, mostly from OS DLLs. Find memory leaks Note: as with Heap Snapshots the utility of UMDH is greatly reduced now because PartitionAlloc Everywhere has mostly replaced the Windows heap. The Windows heap manager has a really useful debug flag, where it can be asked to capture and store a stack trace with every allocation. The tool to scrape these stack traces out of processes is UMDH, which comes with  WinDbg . UMDH is great. It will capture a snapshot of the heap state as many times as you like, and it'll do it fairly quickly. You then run it again against either a single snapshot, or a pair of snapshots, at which time it'll symbolize the stack traces and aggregate usage up to unique stack traces. Turning on the user stack trace database for chrome.exe with gflags.exe makes it run unbearably slowly; however, turning on the user stack trace database on for the browser alone is just fine. While it's possible to turn on the user stack database with the "!gflag" debugging extension, it's too late to do this by the time the initial debugger breakpoint hits. The only reasonable way to do this is to Launch GFlags.exe, Enable the user stack trace database (per image below), Launch Chrome under the debugger. Set a breakpont when chrome.dll loads with "sxe ld chrome.dll". Step up, to allow Chrome.dll to initialize. Disable the stack trace database in GFlags.exe. Continue chrome, optionally detaching the debugger. GFlags.exe settings for user mode stack trace database. If you then ever suffer a browser memory leak, you can snarf a dump of the process with umdh - p :<my browser pid> > chrome-browser-leak-umdh-dump.txt which can then typically be "trivially" analyzed to find the culprit. Miscellaneous Note that by default Application Verifier only works with non-official builds of Chromium. To use Application Verifier on official builds you need to add --disable-features=RendererCodeIntegrity to avoid sandbox crashes in renderer processes. See  crbug.com/1004989  for details. See also  this page . Application Verifier  is a free tool from Microsoft (available as part of the Windows SDK) that can be used to flush out programming errors. Starting with M68 Application Verifier can be enabled for chrome.exe without needing to disable the sandbox. After adding chrome.exe to the list of applications to be stressed you need to expand the list of Basics checks and disable the  Leak  checks. You may also need to disable  Handles  and  Locks  checks depending on your graphics driver and specific Chrome version, but the eventual goal is to have Chrome run with  Handles  and  Locks  checks enabled. When bugs are found Chrome will trigger a breakpoint so running all Chrome processes under a debugger is recommended. Chrome will run much more slowly because Application Verifier puts every heap allocation on a separate page. Note that with PartitionAlloc Everywhere most Chromium allocations don't actually go through the Windows heap and are therefore unaffected by Application Verifier. You can check the undocumented 'Cuzz' checkbox in Application Verifier to get the Windows thread scheduler to add some extra randomness in order to help expose race conditions in your code. To put a breakpoint on CreateFile(), add this break point: {,,kernel32.dll}_CreateFileW@28 {,,kernel32.dll} specifies the DLL (context operator). _ prefix means extern "C". @28 postfix means _stdcall with the stack pop at the end of the function. i.e. the number of arguments in BYTES. You can use  DebugView  from SysInternals or  sawbuck  to view LOG() messages that normally go to stderr on POSIX.

In the digital world, classifying real sensed data in huge volumes derived from numerical problems is a challenging task due to the computational complexity of the metaheuristic searching process. The deep learning approach includes convolutional neural network (CNN), long short-term memory (LSTM), and Bidirectional (BI)-LSTM, suitable for an optimistic processing time of analyzing XML datasets (i.e., social media, trade center, and surveillance data exchanged in the internet world). However, it faces process deviation when datasets extend their range beyond the expected volume. This paper proposes a novel deep learning formwork referred to as archimed improved numerical optimization deep learning (AINODL) to improve the classification of XML datasets. The proposed AINODL framework first extracts feature from XML documents using the vector space model. Secondly, it classifies the XML data using the inbuilt function of the AINODL framework. The experiments demonstrate that the performance parameters accuracy (90%), sensitivity (93%), and specificity (94%) of the proposed AINODL framework are significantly enhanced compared with the existing approaches CNN, LSTM, and BI-LSTM.

In the digital world, classifying real sensed data in huge volumes derived from numerical problems is a challenging task due to the computational complexity of the metaheuristic searching process. The deep learning approach includes convolutional neural network (CNN), long short-term memory (LSTM), and Bidirectional (BI)-LSTM, suitable for an optimistic processing time of analyzing XML datasets (i.e., social media, trade center, and surveillance data exchanged in the internet world). However, it faces process deviation when datasets extend their range beyond the expected volume. This paper proposes a novel deep learning formwork referred to as archimed improved numerical optimization deep learning (AINODL) to improve the classification of XML datasets. The proposed AINODL framework first extracts feature from XML documents using the vector space model. Secondly, it classifies the XML data using the inbuilt function of the AINODL framework. The experiments demonstrate that the performance parameters accuracy (90%), sensitivity (93%), and specificity (94%) of the proposed AINODL framework are significantly enhanced compared with the existing approaches CNN, LSTM, and BI-LSTM.

In the digital world, classifying real sensed data in huge volumes derived from numerical problems is a challenging task due to the computational complexity of the metaheuristic searching process. The deep learning approach includes convolutional neural network (CNN), long short-term memory (LSTM), and Bidirectional (BI)-LSTM, suitable for an optimistic processing time of analyzing XML datasets (i.e., social media, trade center, and surveillance data exchanged in the internet world). However, it faces process deviation when datasets extend their range beyond the expected volume. This paper proposes a novel deep learning formwork referred to as archimed improved numerical optimization deep learning (AINODL) to improve the classification of XML datasets. The proposed AINODL framework first extracts feature from XML documents using the vector space model. Secondly, it classifies the XML data using the inbuilt function of the AINODL framework. The experiments demonstrate that the performance parameters accuracy (90%), sensitivity (93%), and specificity (94%) of the proposed AINODL framework are significantly enhanced compared with the existing approaches CNN, LSTM, and BI-LSTM.

This thesis contributes to the US Navy forces maintaining information superiority in a Network Centric Warfare environment. This research develops an Extensible Markup Language XML-based Web Publishing Framework, which supports the Web Enabled Navy (WEN) architecture infrastructure. The Web application framework easily supports connections to multiple distributed databases and XML-based presentations, specifically three-dimensional (3D) simulations utilizing Extensible 3D (X3D) and Virtual Reality Modeling Language (VRML). This research evaluates and demonstrates the functionality of an XML-based Web Publishing Framework. The research demonstrates ability to connect to both XML and non-XML heterogeneous database systems and provides a framework for the distribution data across heterogeneous systems. The system supports usage in multi-tier network architecture. 3D modeling and simulations provide insights into operations that cannot be realized using standard two-dimensional (2D) renditions. The development of an application server to support 3D modeling and simulations for operational planning will provide the U.S. Navy a better way of realizing operational limits. This research addresses the Web publishing framework, which supports the development XML based data exchange, and the development of an βon the flyγ X3D simulation presentation. This research evaluated the functionality of an XML based Web framework, which allows for the separation between application programming and Web presentation. This incorporation of a Model, View, and Controller (MVC) design approach provides a clean separation between different components (logic, presentation, and data) of information and the programming functionality. The Web framework addressed ability to provide a framework for the distribution data across heterogeneous systems.

Includes bibliographical references (p. 467-470) and index

Includes bibliographical references (p. 467-470) and index

An important capability that many modern 3D interactive training simulations lack is an After Action Review System (AARS) that helps both the trainer and trainee to conduct an After Action Review (AAR). Although AAR is not a new idea in the 3D simulation field, it is not widely used in training simulations. In real life training, AAR has been proven as one of the most important phases of the training procedure, sometimes taking the form of debriefing, or in other cases, by conducting a deeper analysis and discussion of the facts. In order to conduct an AAR, a well-designed system (AARS) must exist to keep track of the conditions and the actions during an exercise, so they can be available for review later. This thesis translates the idea of AAR for real training situations to the 3D interactive simulation domain and also develops an After Action Review System (AARS) using XML technology for capture, analysis, and interactive playback of an entire simulation training session. Users can change the point of view to any desired position and direction, something that is impossible in video streaming playbacks.

An important capability that many modern 3D interactive training simulations lack is an After Action Review System (AARS) that helps both the trainer and trainee to conduct an After Action Review (AAR). Although AAR is not a new idea in the 3D simulation field, it is not widely used in training simulations. In real life training, AAR has been proven as one of the most important phases of the training procedure, sometimes taking the form of debriefing, or in other cases, by conducting a deeper analysis and discussion of the facts. In order to conduct an AAR, a well-designed system (AARS) must exist to keep track of the conditions and the actions during an exercise, so they can be available for review later. This thesis translates the idea of AAR for real training situations to the 3D interactive simulation domain and also develops an After Action Review System (AARS) using XML technology for capture, analysis, and interactive playback of an entire simulation training session. Users can change the point of view to any desired position and direction, something that is impossible in video streaming playbacks.

An important capability that many modern 3D interactive training simulations lack is an After Action Review System (AARS) that helps both the trainer and trainee to conduct an After Action Review (AAR). Although AAR is not a new idea in the 3D simulation field, it is not widely used in training simulations. In real life training, AAR has been proven as one of the most important phases of the training procedure, sometimes taking the form of debriefing, or in other cases, by conducting a deeper analysis and discussion of the facts. In order to conduct an AAR, a well-designed system (AARS) must exist to keep track of the conditions and the actions during an exercise, so they can be available for review later. This thesis translates the idea of AAR for real training situations to the 3D interactive simulation domain and also develops an After Action Review System (AARS) using XML technology for capture, analysis, and interactive playback of an entire simulation training session. Users can change the point of view to any desired position and direction, something that is impossible in video streaming playbacks.

This document describes a method of representing rules for validating identifier labels and alternate representations of those labels using Extensible Markup Language (XML). These policies, known as "Label Generation Rulesets" (LGRs), are used for the implementation of Internationalized Domain Names (IDNs), for example. The rulesets are used to implement and share that aspect of policy defining which labels and Unicode code points are permitted for registrations, which alternative code points are considered variants, and what actions may be performed on labels containing those variants.

Simple and raw tutorial (without audio) showing how to import content from a Mediawiki site to a Tikiwiki site using Mediawiki XML file. This video is part of the collection to show how to import a Mediawiki site to Tikiwiki. For more information see http://doc.tikiwiki.org/Mediawiki+Importer

XML data projection (or pruning) is a natural optimization for main memory query engines: given a query Q over a document D, the subtrees of D that are not necessary to evaluate Q are pruned, thus producing a smaller document D'; the query Q is then executed on D', hence avoiding to allocate and process nodes that will never be reached by Q. In this article, we propose a new approach, based on types, that greatly improves current solutions. Besides providing comparable or greater precision and far lesser pruning overhead, our solution ---unlike current approaches--- takes into account backward axes, predicates, and can be applied to multiple queries rather than just to single ones. A side contribution is a new type system for XPath able to handle backward axes. The soundness of our approach is formally proved. Furthermore, we prove that the approach is also complete (i.e., yields the best possible type-driven pruning) for a relevant class of queries and Schemas. We further validate our approach using the XMark and XPathMark benchmarks and show that pruning not only improves the main memory query engine's performances (as expected) but also those of state of the art native XML databases.

The data has structured is determined using the standard is known as XML whereaslarge amount of data has consumed through internet consist of the both structural data format as well as semi structural data format which gets stored and processed whereas XML allow the data of semi-structured and hierarchical data representation not only consist of concept with individual items from various kind of database but also have relationship among data items. The utilized knowledge bed is provided with concise ideas for both structured and semi structured data files, XML document contents and rapid with exact solutions for the queries required at any time. The user can search their resources with the help of queries. Searching the resources with the help of queries is not a simple task, where inaccurate result and complexity would occur. Hence it is not a better way for searching the resources. This paper proposes the query answering system of Linear search usingwild card searchfor extracting the frequent pattern to maximize your search results in library database on XML document to extract the most relevant feeds from the large file directly. It will help the user to find his resources completely. 

We present an XML-based simulation authoring environment. The proposed description language allows to describe mathematical objects such as systems of ordinary differential equations, partial differential equations in two dimensions, or simple curves and surfaces. It also allows to describe the parameters on which these objects depend. This language is independent of the target software and allows to ensure the perennity of author's work, as well as collaborative work and content reuse. The actual implementation of XMLlab allows to run the generated simulations within the open source mathematical software Scilab, either locally when Scilab is installed on the client machines, or on thin clients running a simple web browser, when XMLlab and Scilab are installed on a distant server running a standard HTTP server.

We present an XML-based simulation authoring environment. The proposed description language allows to describe mathematical objects such as systems of ordinary differential equations, partial differential equations in two dimensions, or simple curves and surfaces. It also allows to describe the parameters on which these objects depend. This language is independent of the target software and allows to ensure the perennity of author's work, as well as collaborative work and content reuse. The actual implementation of XMLlab allows to run the generated simulations within the open source mathematical software Scilab, either locally when Scilab is installed on the client machines, or on thin clients running a simple web browser, when XMLlab and Scilab are installed on a distant server running a standard HTTP server.

Three approaches to content-and-structure XML retrieval are analysed in this paper: first by using Zettair, a full-text information retrieval system; second by using eXist, a native XML database, and third by using a hybrid XML retrieval system that uses eXist to produce the final answers from likely relevant articles retrieved by Zettair. INEX 2003 content-and-structure topics can be classified in two categories: the first retrieving full articles as final answers, and the second retrieving more specific elements within articles as final answers. We show that for both topic categories our initial hybrid system improves the retrieval effectiveness of a native XML database. For ranking the final answer elements, we propose and evaluate a novel retrieval model that utilises the structural relationships between the answer elements of a native XML database and retrieves Coherent Retrieval Elements. The final results of our experiments show that when the XML retrieval task focusses on highly relevant elements our hybrid XML retrieval system with the Coherent Retrieval Elements module is 1.8 times more effective than Zettair and 3 times more effective than eXist, and yields an effective content-and-structure XML retrieval.

This work represents the realization of Network-Centric goals of interoperability, information management, systems integration and cohesive battlespace visualization using networked computer technology. The application of structured data methodologies using the E xtensible Markup Language (XML) allows organizations and systems to exchange and process battlespace information cooperatively. The practical application of this technology is demonstrated. Governance of information systems using structured data and the rejection of proprietary, application specific solutions is a leadership responsibility that is defined as Data Control. XML is presented as a leadership control measure that can be used to achieve Network-Centricity on the battlefield. The fundamental principles of XML application development are presented in the context of warfighting. Exemplars address a cross-section of battlespace applications. The visualization of the physical battlefield is demonstrated with network delivered 3D terrain views. Geodesy and position reporting is addressed using an XML defined data structure to enforce interoperability. An XML expression of the Battlespace Generic Hub is applied to joint and multilateral interoperability and information exchange. An approach to the effective employment of multiple different, but cooperative, autonomous systems in the battlespace uses XML to define parameters that determine artificial intelligence multi-agent behavior and environmental factors. This thesis combines a critical analysis of the priorities of Network- Centricity and interoperability with practical and functional exemplars that demonstrate the efficacy of extensible architectures. The pragmatic approach is directed at the warfighter, and leadership challenges are identified.

Advances in computer communication technology and an increased awareness of how enhanced information access can lead to improved capabilities, are the driving forces behind the interest in the integration of current distributed systems and stand-alone systems. However, differences in hardware, software architectures, operating systems, host languages, and data representation have resulted in scores of stovepipe system architectures that are unable to interoperate prop cAy. This thesis contributes to the US Navy forces' information superiority in a Network Centric Warfare environment. This research develops an Extensible Markup Language (XML) based Web application framework, which supports the Web Enabled Navy (WEN) architecture infrastructure. The Web application framework easily supports connections to multiple distribute databases and XML-based presentations specifically three-dimensional (3D) simulations utilizing Extensible 3D (X3D) and Virtual Reality Modeling Language (VRML).

Efforts to improve the military decision and action cycle have centered on automating the command and control process and improving interoperability among joint and coalition forces. However, information automation by itself can lead to increased operator overload when the way this information is stored and presented is not structured and consistently filtered. The majority of messaging systems store information in a document-centric free-text format that makes it difficult for command and control systems, relational databases, software agents and web portals to intelligently search the information. Consistent structure and semantic meaning is essential when integrating these capabilities. Military-grade implementations must also provide high performance. A widely accepted platform-independent technology standard for representing document-centric information is the Extensible Markup Language (XML). XML supports the structured representation of information in context through the use of metadata. By using an XML Schema generated from MIPâ s Land Command and Control Information Exchange Data Model (LC2IEDM), it is feasible to compare the syntactic strength of human-readable XML documents with the semantics of LC2IEDM as used within a relational database. The insert, update, retrieve and delete performance of a native-XML database is compared against that of a relational database management system (RDBMS) implementing the same command and control data model (LC2IEDM). Additionally, compression and parsing performance advantages of using various binary XML compression schemes is investigated. Experimental measurements and analytic comparisons are made to determine whether the performance of a native-XML database is a disadvantage to the use of XML. Finally, because of the globally significant potential of these interoperability improvements, a number of look-ahead items to future work are proposed including the use of.

Thesis advisor(s): Xie, Geoffrey ; Dolk, Daniel

The presentation describes the experience gained from building a SOA (service Oriented Architecture) based production health care system for the OSU (Ohio State University) Medical Center. The system uniformly treats collection of “medical actions” as generalized electronic medical records. One part of the system allows us to securely and in near real time monitor, record, and replay clinical data being generated in the 50+ ORs at the medical center. Another part of the system (currently under construction) allows patient and equipment tracking by utilizing the existing wireless infrastructure at the medical center. The presentation describes the use of emerging open specifications based on policy to enhance a federation of SOAP XML Web Services. Maintainability is enhanced because declarative security policy enables separation of security concerns from business logic. The system initially used Microsoft’s Web Services Enhancements (WSE) 2.0 implementation of WS-Policy, WS-Trust and WS-SecureConversation open specifications; currently the system is being ported to Microsoft Indigo. The presentation describes patterns of using Web Services in a near real time environment and how using WSE/Indigo can significantly decreased the cost of building and maintaining a secure policy based federated system. ©2005 Microsoft Corporation. All rights reserved.

For the past three decades, the Department of Defense (DoD) has used the U.S. Message Text Format (USMTF) as the primary means to exchange information and to achieve interoperability between joint and coalition forces. To more effectively exchange and share data, the Defense Information Systems Agency (DISA), the lead agency for the USMTF, is actively engaged in extending the USMTF standard with a new data sharing technology called Extensible Markup Language (XML). This work translates and synthesizes Air Tasking Order (ATO) data messages written in XML into a three-dimensional (3D) air attack plan within a virtual environment through the use of the Virtual Reality Modeling Language (VRML).

The data has structured is determined using the standard is known as XML whereaslarge amount of data has consumed through internet consist of the both structural data format as well as semi structural data format which gets stored and processed whereas XML allow the data of semi-structured and hierarchical data representation not only consist of concept with individual items from various kind of database but also have relationship among data items. The utilized knowledge bed is provided with concise ideas for both structured and semi structured data files, XML document contents and rapid with exact solutions for the queries required at any time. The user can search their resources with the help of queries. Searching the resources with the help of queries is not a simple task, where inaccurate result and complexity would occur. Hence it is not a better way for searching the resources. This paper proposes the query answering system of Linear search usingwild card searchfor extracting the frequent pattern to maximize your search results in library database on XML document to extract the most relevant feeds from the large file directly. It will help the user to find his resources completely.

Different agencies and different nations are not able to securely communicate and share structured information due to differences in security policies and data formats. The current evolution of security and data policies is not solving this fundamental problem. Document-based message-centric XML security can provide satisfactory security within a diversified communications framework between traditional and nontraditional partners by utilizing existing Web standards for XML canonicalization, XML digital signature, XML compression and XML encryption. Vulnerabilities related to the exchange of cryptographic technologies are minimized by strictly adhering to open-standards technology. This approach thus resolves multi-partner trust challenges in regards to using another entity's equipment, software, or policy requirements through the proper adoption of standards-based structured data and alternative cryptographic algorithms. Exemplar results demonstrated in this thesis show that XML Security is a feasible approach for operations that include multiple agencies and coalition partners. Alternative solutions are also available using proprietary technologies, but such approaches lock participants into commercial contracts, prohibit distribution and provide suspect capabilities. Therefore, they cannot attain interagency or international acceptance. Such methods involve the use of unique or proprietary message formats with customized encryption and compression algorithms that are not available for broad scrutiny by open source communities. Closed approaches cannot gain group trust. This thesis specifically investigates XML standardization methods for various categories of unclassified data to provide secure information exchange among a wide audience, e.g. multi-agency task force or multinational coalition partners. Using an XML document-centric approach is a helpful organizing principle for this problem that provides levels of security consistent with common business practices achieved, within the constraints of the respective organizational security policies of each participant. The resulting design patterns for XML document development enhance confidentiality, integrity, and authentication commensurate with the nature of the unclassified document generated, while maintaining information objects at an appropriate level of security and acceptable level of risk.

Different agencies and different nations are not able to securely communicate and share structured information due to differences in security policies and data formats. The current evolution of security and data policies is not solving this fundamental problem. Document-based message-centric XML security can provide satisfactory security within a diversified communications framework between traditional and nontraditional partners by utilizing existing Web standards for XML canonicalization, XML digital signature, XML compression and XML encryption. Vulnerabilities related to the exchange of cryptographic technologies are minimized by strictly adhering to open-standards technology. This approach thus resolves multi-partner trust challenges in regards to using another entity's equipment, software, or policy requirements through the proper adoption of standards-based structured data and alternative cryptographic algorithms. Exemplar results demonstrated in this thesis show that XML Security is a feasible approach for operations that include multiple agencies and coalition partners. Alternative solutions are also available using proprietary technologies, but such approaches lock participants into commercial contracts, prohibit distribution and provide suspect capabilities. Therefore, they cannot attain interagency or international acceptance. Such methods involve the use of unique or proprietary message formats with customized encryption and compression algorithms that are not available for broad scrutiny by open source communities. Closed approaches cannot gain group trust. This thesis specifically investigates XML standardization methods for various categories of unclassified data to provide secure information exchange among a wide audience, e.g. multi-agency task force or multinational coalition partners. Using an XML document-centric approach is a helpful organizing principle for this problem that provides levels of security consistent with common business practices achieved, within the constraints of the respective organizational security policies of each participant. The resulting design patterns for XML document development enhance confidentiality, integrity, and authentication commensurate with the nature of the unclassified document generated, while maintaining information objects at an appropriate level of security and acceptable level of risk.

xxvi, 564 p. : 24 cm

xxvii, 529 p. : 24 cm

This document presents a technique for using a Markdown syntax variant, called Pandoc, and a bit of XML (as defined in RFC 2629) as a source format for documents that are Internet-Drafts (I-Ds) or RFCs.

With the unveiling of ForceNet, the Navy's architectural framework for how naval warfare is to be conducted in the information age, much of the technological focus has been placed on Web technology. One of the most promising technologies is Web services. Web services provide for a standard way to move and share data more reliably, securely, and quickly. The capabilities imbedded in Extensible Markup Language (XML) and Simple Object Access Protocol (SOAP) can merge previously disparate systems into one integrated environment. Already proven successful in the administrative realm, wide-area networks such as the Secure Internet Protocol Network (SIPRNET) have become secure and reliable enough to pass data between systems and units to support tactical operations. The Modeling, Virtual Environments and Simulation (MOVES) Institute at the Naval Postgraduate School is currently working to extend these precepts into the modeling and simulation world under the Extensible Modeling and Simulation Framework (XMSF) project. By leveraging existing Web service technology, warfighters at the \"tip of the spear\" can have access to previously unrealized amounts of tactically-relevant data, analysis, and planning tools. The goal of this thesis is to apply the XMSF and Extensible 3D (X3D) graphics to the field of sonar visualization. Undersea warfare is a complex operation that requires a continuous and detailed analysis of the acoustic environment. Tactical sensor employment without a firm understanding of the complete undersea picture can lead to fatal consequences. The Navy has spent significant resources to develop training systems and tactical decision aids in an effort to integrate training, rehearsal and execution. Unfortunately, many of the high-resolution analysis tools that can provide high-resolution sonar prediction results are not easily accessible to the fleet. By taking advantage of Web services and XMSF technology, warfighters will need only access to the network to be able to pull real-time environmental analysis data from large databases, remotely run sonar prediction models on supercomputers, and view detailed three-dimensional (3D) virtual worlds that visualize the undersea picture.

This new book on PHP 7 introduces writing solid, secure, object-oriented code in the new PHP 7: you will create a complete three-tier application using a natural process of building and testing modules within each tier. This practical approach teaches you about app development and introduces PHP features when they are actually needed rather than providing you with abstract theory and contrived examples. In Learn PHP 7, programming examples take advantage of the newest PHP features, including enhanced password encryption using password_hash. This book takes a learn-by-doing approach, providing you with complete coding examples. "Do It" exercises in each chapter provide the opportunity to make adjustments to the example code. The end of chapter programming exercises allow you to develop your own applications using the algorithms demonstrated in the chapter. Each tier is logically and physically separated using object-oriented and dependency injection techniques, thus allowing independent tiers that can be updated with little or no effect on the other tiers. In addition to teaching good programming practices through OOP, there is a strong emphasis on creating secure code. As each chapter is completed, the reader is provide the opportunity to design and create an application reinforcing the concepts learned.

The presentation describes the experience gained from building a SOA (service Oriented Architecture) based production health care system for the OSU (Ohio State University) Medical Center. The system uniformly treats collection of “medical actions” as generalized electronic medical records. One part of the system allows us to securely and in near real time monitor, record, and replay clinical data being generated in the 50+ ORs at the medical center. Another part of the system (currently under construction) allows patient and equipment tracking by utilizing the existing wireless infrastructure at the medical center. The presentation describes the use of emerging open specifications based on policy to enhance a federation of SOAP XML Web Services. Maintainability is enhanced because declarative security policy enables separation of security concerns from business logic. The system initially used Microsoft’s Web Services Enhancements (WSE) 2.0 implementation of WS-Policy, WS-Trust and WS-SecureConversation open specifications; currently the system is being ported to Microsoft Indigo. The presentation describes patterns of using Web Services in a near real time environment and how using WSE/Indigo can significantly decreased the cost of building and maintaining a secure policy based federated system. ©2005 Microsoft Corporation. All rights reserved.

The purpose of grant NCC3-966 was to investigate and evaluate the interchange of application-specific data among multiple programs each carrying out part of the analysis and design task. This has been carried out previously by creating a custom program to read data produced by one application and then write that data to a file whose format is specific to the second application that needs all or part of that data. In this investigation, data of interest is described using the XML markup language that allows the data to be stored in a text-string. Software to transform output data of a task into an XML-string and software to read an XML string and extract all or a portion of the data needed for another application is used to link two independent applications together as part of an overall design effort. This approach was initially used with a standard analysis program, Lapin, along with standard applications a standard spreadsheet program, a relational database program, and a conventional dialog and display program to demonstrate the successful sharing of data among independent programs. Most of the effort beyond that demonstration has been concentrated on the inclusion of more complex display programs. Specifically, a custom-written windowing program organized around dialogs to control the interactions have been combined with an independent CAD program (Open Cascade) that supports sophisticated display of CAD elements such as lines, spline curves, and surfaces and turbine-blade data produced by an independent blade design program (UD0300).

Efforts to improve the military decision and action cycle have centered on automating the command and control process and improving interoperability among joint and coalition forces. However, information automation by itself can lead to increased operator overload when the way this information is stored and presented is not structured and consistently filtered. The majority of messaging systems store information in a document-centric free-text format that makes it difficult for command and control systems, relational databases, software agents and web portals to intelligently search the information. Consistent structure and semantic meaning is essential when integrating these capabilities. Military-grade implementations must also provide high performance. A widely accepted platform-independent technology standard for representing document-centric information is the Extensible Markup Language (XML). XML supports the structured representation of information in context through the use of metadata. By using an XML Schema generated from MIP's Land Command and Control Information Exchange Data Model (LC2IEDM), it is feasible to compare the syntactic strength of human-readable XML documents with the semantics of LC2IEDM as used within a relational database.

Efforts to improve the military decision and action cycle have centered on automating the command and control process and improving interoperability among joint and coalition forces. However, information automation by itself can lead to increased operator overload when the way this information is stored and presented is not structured and consistently filtered. The majority of messaging systems store information in a document-centric free-text format that makes it difficult for command and control systems, relational databases, software agents and web portals to intelligently search the information. Consistent structure and semantic meaning is essential when integrating these capabilities. Military-grade implementations must also provide high performance. A widely accepted platform-independent technology standard for representing document-centric information is the Extensible Markup Language (XML). XML supports the structured representation of information in context through the use of metadata. By using an XML Schema generated from MIP's Land Command and Control Information Exchange Data Model (LC2IEDM), it is feasible to compare the syntactic strength of human-readable XML documents with the semantics of LC2IEDM as used within a relational database.

Efforts to improve the military decision and action cycle have centered on automating the command and control process and improving interoperability among joint and coalition forces. However, information automation by itself can lead to increased operator overload when the way this information is stored and presented is not structured and consistently filtered. The majority of messaging systems store information in a document-centric free-text format that makes it difficult for command and control systems, relational databases, software agents and web portals to intelligently search the information. Consistent structure and semantic meaning is essential when integrating these capabilities. Military-grade implementations must also provide high performance. A widely accepted platform-independent technology standard for representing document-centric information is the Extensible Markup Language (XML). XML supports the structured representation of information in context through the use of metadata. By using an XML Schema generated from MIP's Land Command and Control Information Exchange Data Model (LC2IEDM), it is feasible to compare the syntactic strength of human-readable XML documents with the semantics of LC2IEDM as used within a relational database.

The Department of Defense (DoD) is facing significant interoperability issues within the Services as they seek to architect solutions for distributed systems composed of clients and servers of heterogeneous hosts to enable joint service operations. The eXtensible Markup Language (XML) and related technologies offer promise for applying data management technology to documents and also for providing a neutral syntax for interoperability among disparate systems. This paper describes the work performed by Mitre Corp for the Army Systems Engineering Office (ASEO), particularly the results of applying XML and other leading-edge software technologies to enable interoperability among dissimilar databases and message formats. The solution approach taken by Mitre investigated the utility of XML to write translator(s) between message formats and databases to reduce operator burden and to increase interoperability. Further, they investigated other leading-edge software technologies to address the information portability issues associated with distributed systems. The demonstration shows how a U.S. Marine Corps message scenario of battlefield engagement can interoperate with the U.S. Army via automated message translation and database interoperability. The experimental distributed architecture is presented along with the findings of the proof of concept demonstration.

This work represents the realization of Network-Centric goals of interoperability, information management, systems integration and cohesive battlespace visualization using networked computer technology. The application of structured data methodologies using the Extensible Markup Language (XML) allows organizations and systems to exchange and process battlespace information cooperatively. The practical application of this technology is demonstrated. Governance of information systems using structured data and the rejection of proprietary, application specific solutions is a leadership responsibility that is defined as Data Control. XML is presented as a leadership control measure that can be used to achieve Network-Centricity on the battlefield. The fundamental principles of XML application development are presented in the context of warfighting. Exemplars address a cross-section of battlespace applications. The visualization of the physical battlefield is demonstrated with network delivered 3D terrain views. Geodesy and position reporting is addressed using an XML defined data structure to enforce interoperability. An XML expression of the Battlespace Generic Hub is applied to joint and multilateral interoperability and information exchange. An approach to the effective employment of multiple different, but cooperative, autonomous systems in the battlespace uses XML to define parameters that determine artificial intelligence multi agent behavior and environmental factors. This thesis combines a critical analysis of the priorities of Network-Centricity and interoperability with practical and functional exemplars that demonstrate the efficacy of extensible architectures. The pragmatic approach is directed at the warfighter, and leadership challenges are identified.

This thesis investigates how the Extensible Markup Language (XML) can be used to describe application-specific networking protocols for use in the NPSNET-V Virtual Environment. Specifically, it describes design of the NPS Dynamic-Behavior-Protocol (DBP) protocols, which are multicast / unicast capable and can be added at runtime to the distributed operating environment. With XML- described packet payloads for these protocols, supporting configuration documents can concisely and clearly describe different variations of these protocols and can also enable switching between them at runtime.

This thesis investigates how the Extensible Markup Language (XML) can be used to describe application-specific networking protocols for use in the NPSNET-V Virtual Environment. Specifically, it describes design of the NPS Dynamic-Behavior-Protocol (DBP) protocols, which are multicast / unicast capable and can be added at runtime to the distributed operating environment. With XML- described packet payloads for these protocols, supporting configuration documents can concisely and clearly describe different variations of these protocols and can also enable switching between them at runtime.

The AIAA Modeling and Simulation Technical Committee has worked for several years to develop a standard by which the information needed to develop physics-based models of aircraft can be specified. The purpose of this standard is to provide a well-defined set of information, definitions, data tables and axis systems so that cooperating organizations can transfer a model from one simulation facility to another with maximum efficiency. This paper proposes using an application of the eXtensible Markup Language (XML) to implement the AIAA simulation standard. The motivation and justification for using a standard such as XML is discussed. Necessary data elements to be supported are outlined. An example of an aerodynamic model as an XML file is given. This example includes definition of independent and dependent variables for function tables, definition of key variables used to define the model, and axis systems used. The final steps necessary for implementation of the standard are presented. Software to take an XML-defined model and import/export it to/from a given simulation facility is discussed, but not demonstrated. That would be the next step in final implementation of standards for physics-based aircraft dynamic models.