Patent application number | Description | Published |
20130060730 | ADJUSTING ONE OR MORE TRACE FILTERS IN A DATABASE SYSTEM - Methods and systems for adjusting trace filters in a database system are described. During operation, an embodiment may receive, from a user, an indication of a performance problem. Next, the embodiment may determine settings of one or more trace filters based on the indication of the performance problem. The embodiment may then collect trace data based on the one or more trace filters. While the trace data is being collected, the embodiment may perform the following set of operations one or more times: (1) obtain database system performance metrics, (2) analyze the trace data to obtain an analysis result, and (3) adjust the settings of the one or more trace filters based on the database system performance metrics and the analysis result. | 03-07-2013 |
20130060731 | ENUMERATING WMI OBJECT PROPERTIES THROUGH T-SQL - Methods and systems for collecting performance data are described. During operation a database server can receive a set of T-SQL statements, wherein the database server executes on a computer system and provides access to a database. Next, the database server can execute the set of T-SQL statements, thereby causing the database server to: (1) create an external script which, when executed by the computer system, collects performance data in a file; (2) execute the external script on the computer system; (3) wait for the external script to complete execution; and (4) load the performance data from the file into a table in the database. | 03-07-2013 |
20130060762 | RANKING ANALYSIS RESULTS BASED ON USER PERCEIVED PROBLEMS IN A DATABASE SYSTEM - Methods and systems for ranking analysis results based on user perceived problems of a database system are described. During operation, an embodiment may receive a designation of a perceived database system performance problem from a user, wherein the problem is associated with one or more database system metrics. Next, the embodiment may determine a set of recommendations for alleviating the perceived database system performance problem. The embodiment may then analyze the set of recommendations to determine, for each recommendation in the set of recommendations, an impact the recommendation is expected to have on the one or more database system metrics. Finally, the embodiment may rank the set of recommendations according to the impact each recommendation is expected to have on the perceived database performance problem. | 03-07-2013 |
20130060782 | DETERMINING INDEXES FOR IMPROVING DATABASE SYSTEM PERFORMANCE - Methods and systems for identifying one or more indexes are described. A system can collect a set of database operations that were performed during a given time window. Next, the system can partition the set of database operations based on a set of database tables that were accessed by the set of database operations. Then, for each database table in the set of database tables, the system can determine a set of indexes that are candidates for improving database system performance. Next, based on the candidate indexes, the system can identify one or more indexes, one or more combinations of indexes, and/or a consolidated index that improve overall database system performance. | 03-07-2013 |
Patent application number | Description | Published |
20090307663 | DEBUGGING SUPPORT FOR TASKS IN MULTITHREADED ENVIRONMENTS - A debugger enhancement provides a debug-task-provider interface whose implementation includes routines designed to support debugging of programs that contain tasks written for a specific programming model. Task creation hierarchies, individual task properties, resource dependencies, synchronization dependencies, and other information can be made accessible during debugging, through a model-independent interface. In a multithreaded environment, a mapping between tasks and threads is also available. | 12-10-2009 |
20120324465 | WORK ITEM PROCESSING IN DISTRIBUTED APPLICATIONS - A system for organizing messages related to tasks in a distributed application is disclosed. The system includes a work-list creator to create a work list of the top-level work items to be accomplished in performing a task. Work-item processors are distributed in the system. The work-item processors process the top-level work item included in a task and also append additional work items to the work list. A work-list scheduler invokes the work-item processors so local work-item processors are invoked prior to remote work-item processors. | 12-20-2012 |
20120324479 | OBJECT MARSHALING - Object marshaling techniques in a marshaling system for computer networks are disclosed. A gesture is provided to the object marshaling system that a reference object has expired on a sender side and a target side when the reference object is closed. Parent and child relationships are recognized in a descendent reference object to the reference object. The descendent reference object closes when the reference object closes. | 12-20-2012 |
20140282427 | DIAGNOSTICS OF STATE TRANSITIONS - A method for diagnosing computer readable instructions related to transfers of control is disclosed. A state transition of a unit of execution within a logical operation is logged during runtime of the computer readable instructions. Diagnostic information of the logical operation is associated with the state transition. The state transition and associated diagnostic information is provided for retrieval at a selected point in the computer readable instructions. | 09-18-2014 |
Patent application number | Description | Published |
20090307528 | SIMULATING OPERATIONS THROUGH OUT-OF-PROCESS EXECUTION - The present invention extends to methods, systems, and computer program products for simulating operations through out-of-process execution. When a diagnostic operation is to be performed for a target execution context, a separate execution context is created based on the same executable code used to create the target execution context. An execution boundary separates the target execution context and the separate execution context such that execution in the separate execution context does not influence the behavior of the target execution context. State data from the target execution context is marshaled and transferred to the separate execution context. The separate execution context reconstitutes the state data and uses the state data to perform the diagnostic operation. Accordingly, performance of the diagnostic operation is simulated in the separate execution context without influencing the behavior of the target execution context. | 12-10-2009 |
20100192134 | MAPPING BREAKPOINTS BETWEEN WEB BASED DOCUMENTS - The present invention extends to methods, systems, and computer program products for mapping breakpoints between Web based documents. Embodiments of the invention facilitate extracting corresponding client script blocks from different Web based documents to disassociate the client script blocks with their relative locations within the Web based documents. From the extracted client side script blocks, a position for mapping a breakpoint from one client side script block another client side script block can be determined. The breakpoint is then copied from the one client script block and inserted into the determined position in the other client script block. The client script blocks can then be re-associated with their relative locations in the Web based documents from which they were extracted. | 07-29-2010 |
20150199259 | Exception and Debugging Behaviors for JavaScript Debugging using Just My Code - Just My Code debugging allows developers to work on problems within their own code without noise from libraries, plugins and other unrelated code. Typical debugger behaviors may be modified based upon the identification or characterization of JavaScript code as “My Code,” “Library Code,” or “Unrelated Code.” The debugger behaviors that may be modified depending upon the code's characterization include, for example, first-chance exception handling, unhandled exception handling, the behavior of the debugger at explicit user breakpoints, the behavior when a user directs the debugger to break upon the next statement, and the behavior of the debugger when the user executes a stepping gesture. The debugger's visualizes core elements of the program state, such as the call stack, depending upon the identification or characterization of the code. | 07-16-2015 |
20150199261 | Classification of JavaScript Code for Debugging using Just My Code - Just My Code debugging allows developers to work on problems within their own code without noise from libraries, plugins and other unrelated code. Typical debugger behaviors may be modified based upon the identification or characterization of JavaScript code as “My Code,” “Library Code,” or “Unrelated Code.” The debugger behaviors that may be automatically determined using heuristics or set using a code-characterization file provided by a host application. The debugger receives project file information from the host application via a debugger-host interface. The debugger applies code-designation heuristics to undesignated code segments. If a code characterization file is received with the project information, the debugger designates application code segments based upon definitions in the code-characterization file. Once the debugger has characterized the code segments, it performs debugging operations on the application code. The behavior of the debugging operations may be selected depending upon the designation of the application code segments. | 07-16-2015 |
Patent application number | Description | Published |
20100153693 | CODE EXECUTION WITH AUTOMATED DOMAIN SWITCHING - Within the field of computing, many scenarios involve the execution of an instruction set within a domain that is configured to support an execution context. However, various portions of the instruction set may be preferably executed in different domains, such as for promoting performance and for providing debugging features like the ability to simulate execution of a debuggee function without incurring side-effects in the debuggee. Portions of the instruction set may therefore be executed in different domains by inserting domain switch points in the instruction set specifying a target domain. The instruction set may then initiate execution in an initial domain, and upon reaching a domain switch point, may transition to the target domain. In some embodiments, the domain switch points may be automatically inserted into the target instruction set based on various domain switch criterion, such as performance, reliability, and affinity of an instruction with a particular domain. | 06-17-2010 |
20100161910 | STORED VALUE ACCESSORS IN SHARED MEMORY REGIONS - Instruction sets in computing environments may execute within one of several domains, such as a natively executing domain, an interpretively executing domain, and a debugging executing domain. These domains may store values in a shared region of memory in different ways. It may be difficult to perform operations on such values, particularly if a domain that generated a particular value cannot be identified or no longer exist, which may obstruct shared accessing of values and evaluative tasks such as stack walks. Instead, accessors may be associated with a stored value that perform various operations (such as low-level assembly instructions like Load, Store, and Compare) according to the standards of the value-generating domain, and domains may be configured to operate on the value through the accessors. This configuration may promote consistent accessing of values without having to identify or consult the value-generating domain or reconfiguring the instruction sets. | 06-24-2010 |
20120084753 | DEBUGGER LAUNCH AND ATTACH ON COMPUTE CLUSTERS - Launching a debugging process. A method includes at a compute node on a cluster private network, receiving a debug job via a scheduler of a head node from a client on a public network. The head node is connected to both the cluster private network and the public network. The public network is external to the cluster private network. The method further includes beginning processing the debug job, and as a result initiating debugging by starting one or more debugger remote agents at the compute node. The method further includes beginning processing a user job in the presence of the started debugger remote agents at the compute node. The client is informed that the one or more debugger remote agents are ready to debug the user job. A debugger client at the client is connected to the one or more debugger remote agents. | 04-05-2012 |
20120266144 | STEPPING OUT OF AN ASYNCHRONOUS METHOD INTO ITS CONTINUATION IN A DEBUGGER - Stepping out of an asynchronous process. A method includes, as part of a computer program execution, at a caller, making an asynchronous function call from the caller to a callee. Associated with the asynchronous function call a continuation waits for the completion of the callee with respect to the asynchronous function call. The method further includes correlating a debugging indicator to the callee indicating that a user wishes to step out of the caller when the callee returns. An indication of completion of the callee with respect to the asynchronous function call and that a user wishes to step from the callee to the continuation is received. The debugging indicator is referenced and based on the debugging indicator execution at entry into the continuation is stopped. | 10-18-2012 |
20120304156 | REDUCING NETWORK TRIPS FOR REMOTE EXPRESSION EVALUATION - An expression can be evaluated in a remote debugging environment with one single round trip across the network. An expression evaluator on a local machine can compile the expression into a language-independent intermediate language (IL) that encodes all the information needed to evaluate the expression in the absence of a symbol table. The IL can include instructions that manipulate state inside the debuggee process, as well as logical operations needed to process the information. The IL language can be turing complete so that any computation needed to determine the state to read and write and how the information gathered is to be combined can be performed. The IL can be sent to the remote computer and can be interpreted on the remote computer. The IL can be interpreted on the remote computer using a stack based mechanism, without the need to access symbolic information on the local computer. | 11-29-2012 |
20120331351 | N-WAY RUNTIME INTEROPERATIVE DEBUGGING - Simultaneous debugging of code running in multiple types of runtime environment can be performed by an n-way interoperative debugging environment. Code running within a particular runtime can be debugged simultaneously with a code running within other runtimes within a single process. Out-of-process debugging support is provided for inspection and execution control. A compatible debugger or runtime communication protocol is used. Transitions from one runtime to another runtime can be detected. Exceptions thrown in one runtime can be caught by another runtime. Stepping operations can occur in multiple runtimes. A callstack including frames from multiple runtimes can be walked. | 12-27-2012 |
20140282417 | JAVASCRIPT DEBUGGING USING JUST MY CODE - The present invention extends to methods, systems, and computer program products for stepping through JavaScript code in a debugger without landing on errors in library or open source code. A debugger receives user inputs designating one or more segments of the JavaScript code as library code. The debugger then performs debugging operations on the JavaScript code. The debugging operations including a stepping operation for stepping through the JavaScript code to identify errors only in user-generated segments of the JavaScript code, wherein the user-generated segments correspond to code that was not designated as library code. | 09-18-2014 |
Patent application number | Description | Published |
20090328005 | DEBUGGER CALL STACK CACHING - A debugger backend computes and stores a previous call stack of multiple threads of a debuggee process based on previous call stack information provided from a debugging agent. The debugger backend stores a first hash of threads of the debuggee process and stack memory of the previous call stack. The debugger backend sends the first hash to the debugging agent in response to a request of the current call stack from a debugger user interface (UI), and provides the previous call stack to the debugger UI in response to the debugging agent indicating that that first hash matches a second hash of thread registers of the debuggee process and stack memory of the current call stack. | 12-31-2009 |
20130311973 | Assisting Development Tools Through Inserted Code Statements - Aspects of the subject matter described herein relate to assisting development tools. In aspects, statements that influence runtime behavior may be inserted into code of a program. For example, a statement inserted into a function may set a property of a runtime object to indicate that a debugger is to be notified for exceptions that are encountered within the scope of the function. When a runtime environment encounters an exception, the runtime environment may determine whether the property applies to the currently-executing scope. If so, the runtime environment may notify or not notify a development tool of the exception based on the value of the property. | 11-21-2013 |
20140053142 | Imperative Attribution for Elements in Managed Runtimes - Aspects of the subject matter described herein relate to imperative attribution. In aspects, metadata of a managed runtime environment may be set by imperative statements included in code of a program executing in the managed runtime environment. The metadata may be associated with lookup data that identifies the metadata. The lookup data may be formed from an identifier supplied by an imperative statement and an identifier of a logical element which may be explicitly or implicitly supplied. The metadata may be computed at parse time, run time, or another time and may be computed based on state available to a managed runtime environment at the time the metadata is computed. | 02-20-2014 |
20140068544 | OBTAINING METADATA SET BY IMPERATIVE STATEMENT - Aspects of the subject matter described herein relate to imperative attribution. In aspects, metadata of a managed runtime environment may be set by imperative statements included in code of a program executing in the managed runtime environment. A metadata consumer may request the metadata. A metadata identifier of the metadata requested may be provided implicitly or explicitly. A parameter that indicates how to obtain the metadata may also be provided. In response, the metadata may be obtained and provided. The metadata may be computed at parse time, run time, or another time and may be computed based on state available to a managed runtime environment at the time the metadata is computed. | 03-06-2014 |
Patent application number | Description | Published |
20110307281 | MODEL INVENTORY MANAGER - A method and apparatus for managing a building model inventory, including a database structured for storing element specification and instance data from both a previous version and a latter revision of building information modeling datasets, respectively. In addition to the building information modeling element data, the database associates completed assembly pass, unit cost, work breakdown structure, and other inventory management data with the element type definitions and element instance data. Application software compares the first and second inventory revisions to identify all changes, additions and/or deletions of building elements between the previous version and the latter revision of the building information modeling datasets. By tracking the elements that change, the changes that affect the construction schedule and quantity, configuration and specification of materials are identified. An engineering cost analysis based on the changed data provides a rapid understanding of the implications of any design change. | 12-15-2011 |
20150019178 | System And Method For Managing Changes In Building Information Models - A method and apparatus for managing a building model inventory, including a database structured for storing element specification and instance data from both a previous version and a latter revision of building information modeling datasets, respectively. In addition to the building information modeling element data, the database associates completed assembly pass, unit cost, work breakdown structure, and other inventory management data with the element type definitions and element instance data. Application software compares the first and second inventory revisions to identify all changes, additions and/or deletions of building elements between the previous version and the latter revision of the building information modeling datasets. By tracking the elements that change, the changes that affect the construction schedule and quantity, configuration and specification of materials are identified. An engineering cost analysis based on the changed data provides a rapid understanding of the implications of any design change. | 01-15-2015 |