Abstract: Aspects of the present invention provide a system and method for a user of an event-driven simulator to specify breakpoint conditions in kernel modules, startup processes, shared libraries, and other automatically loaded software elements before the target environment is initialized. The virtual platform detects specified breakpoints when a file is loaded onto a virtual platform debugger during startup of the environment or initialization of the relevant processes. The virtual platform debugger may scan for specified breakpoints in all loaded source code files, in only those source code files that are automatically loaded, or in only those source code files specified by the designer as modified.

Abstract: A debugger executes on a computer system to receive a first debugging command from a client, where the first debugging command sets a first instruction in the reactive application to suspend execution of the reactive application, and where during execution of the reactive application the first instruction is triggered which suspends execution of the reactive application. Responsive to the execution of the reactive application being suspended, a system clock of the reactive application is replaced with a substitute clock and the substitute clock is paused. The debugger then receives a second debugging command, where the second debugging command triggers a second instruction in the reactive application to continue execution of the reactive application. Responsive to the execution of the reactive application being continued, clocking of the substitute clock is continued.

Abstract: In some embodiments, a server application can provide a web document to a development application. The web document is dynamically generated from source files. The web document includes element code segments for rendering respective elements of the web document in a browser. Each element code segment includes respective metadata for identifying a respective source file used to generate the element code segment. The server application can receive a breakpoint request from the development application to insert at least one breakpoint in at least one source file identifiable using the metadata in the web document. The server application can insert the breakpoint in the source file responsive to the breakpoint request. The server application can provide an updated web document to the development application. The updated web document includes a subset of the element code segments dynamically generated by executing source code up to the breakpoint in the source file.

Abstract: An approach for dynamic test topology visualization is provided. The approach retrieves test data from one or more databases. The approach retrieves test data from an application under test. The approach creates a visual diagram, wherein the visual diagram includes one or more topological elements, one or more topological relationships between the one or more topological elements, the test data, and a screen snapshot of an application under test. The approach overlays the visual diagram with user interaction information. The approach associates the visual diagram to the test execution performed on the application under test.

Abstract: An electronic device includes an authentication section that authenticates a user of the electronic device, an operation section that includes a display section and operates the electronic device, a storage section that stores programs that each cause the electronic device to perform a job in accordance with a preliminarily set content, and a program processing section that generates a program associated with the user authenticated in the authentication section. Using the operation section, a first user specifies a program to be shared and a second user permitted to use the shared program. As such, the first user who permits to share the program shares the program with the second user.

Abstract: A method detects unauthorized access of data, and includes receiving data from a content provider by a content reproducing device; storing the received data in a memory storage device of the content reproducing device; obtaining an address range of a buffer of the content reproducing device; intercepting system application programming interface calls related to memory access of the address range of the buffer; comparing the intercepted system application programming interface calls to an expected sequence of memory access calls; and determining that a particular memory access call is unauthorized when the particular memory access call accesses the address range of the buffer while not belonging to the expected sequence of memory access calls.

Abstract: Methods, systems, and computer program products are provided that enable incremental compilation of source code. Attributes of an intermediate language (IL) representation and a compiled representation of a source code are stored. Modified source code that is a revised version of the first source code is received. An IL representation of the modified source code is generated. Attributes of the revised intermediate IL and the stored attributes of the IL representation are compared to determine a first set of functions changed in the modified source code. A second set of functions in the first source code is determined that includes functions affected the determined first set of functions. The first and second sets of functions are compiled to generate a set of compiled functions. Compiled versions of the first and second sets are replaced in the compiled representation of the first source code with the set of compiled functions.

Abstract: A method for dynamically adjusting an actual wait period associated with an operating system call, wherein the operating system call suspends execution of at least one thread in a plurality of threads associated with an operating environment is provided. The method may include determining a utilization factor function associated with the operating environment. The method may also include selecting at least one performance counter within a plurality of performance counters associated with the operating environment. The method may further include computing a utilization factor based on the determined utilization factor function and the selected at least one performance counter. Additionally, the method may include intercepting an operating system call, wherein the operating system call includes a requested wait period parameter.

Abstract: Embodiments are disclosed for striping a directed graph, e.g., a social graph, so as to efficiently perform an operation to each node in the directed graph. At least some of the embodiments can select first and second sets of nodes from the directed graph to form first and second stripes. The first and second sets of nodes are selected, for example, based on available computing resources. First and second intermediate results can be generated by performing the operation to each node of the first and the second stripes, respectively. The operation iteratively performs a superstep. The first and the second intermediate results are combined to form a collective result as an output of the superstep.

Abstract: A method for capturing breakpoint information from a debuggee software process includes generating a breakpoint condition based upon a breakpoint request received from a user computing device corresponding to a user and transmitting the generated breakpoint condition to debuglets, each corresponding to a software process executed by a debuggee service. The debuggee service executes on a distributed system, and each debuglet translates the generated breakpoint condition to a physical breakpoint condition set to the respective software process. The method also includes receiving a request from one of the debuglets to update active breakpoint information captured by the debuglet upon the physical breakpoint condition being hit by one of the software processes and transmitting a notification from the processing device indicating the physical breakpoint condition being hit to the user computing device.

Abstract: A system includes a client system comprising a memory and a processor configured to execute a debugging tool. The debugging tool is communicatively coupled to an OPC Unified Architecture (UA) server. Furthermore, the debugging tool is configured to monitor and control, from the client system, debugging of an application executing on the OPC UA server.

Abstract: In one embodiment, a remote debugging infrastructure may allow a local application 114 to be debugged in real time. A remote debugging operator 120 may establish a connection with an execution platform 112 via a local application 114 activated by the execution platform 112. The remote debugging operator 120 may access an operational state of the local application 114.

Abstract: Software executed at a data processor unit includes a software debugger. The software debugger can be assigned responsibility for servicing a debug event, and be authorized to allow software control of debug event resources associated with the debug event. An indicator, when asserted, prevents a authorized request by software to control a debug event resource.

Abstract: 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.

Abstract: A processor recognizes a request from a program executing on a first hardware thread to initiate software code on a second hardware thread. In response, the second hardware thread initiates and commences executing the software code. During execution, the software code uses hardware registers of the second hardware thread to store data. Upon termination of the software code, the second hardware thread invokes a hypervisor program, which extracts data from the hardware registers and stores the extracted data in a shared memory area. In turn, a debug routine executes and retrieves the extracted data from the shared memory area.

Abstract: The debugging of a program in a data parallel environment. A connection is established between a debugging module and a process of the data parallel environment. The connection causes the data parallel environment to notify the debugging module of certain events as they occur in the execution of the process. Upon notification of such an event, the process execution is paused, and the debugging module may query the data parallel environment for information regarding the process at the device independent virtual machine layer. Upon completion of this querying, the process may then resume execution. This may occur repeatedly if multiple events are encountered.

Abstract: An indication of a start of an execution of a process can be received, and a time counter associated with measuring a time elapsed can be initiated by the execution of the process. The time elapsed by the execution of the process can be compared with a predetermined threshold timeout value, and a report indicating the time elapsed by the execution of the process and whether the elapsed time exceeded the predetermined threshold timeout value can be automatically generated.

Abstract: A debug circuit of a microcomputer, providing an on-chip debug function, is provided as a measurement permission circuit for outputting a measurement permission signal to a timer that measures, as a measurement object, a time period between two events in a program execution period of the CPU, according to a user-specified condition. The measurement permission circuit includes an interrupt level register for setting an interrupt level that either permits or prohibits a time measurement operation of the timer, and a comparator for determining by comparison a high-low relationship between an interrupt level of an interrupt process executed by the CPU and an interrupt level set in the interrupt level register, and a determination result of the comparator is specified as the measurement permission signal.

Abstract: Techniques are described for debugging a processing element (or elements) in a stream based database application in a manner that reduces the impact of debugging the processing element (or elements) on the overall running environment by selectively fusing (or un-fusing) processing elements running on a group of compute nodes. In addition to fusing and un-fusing processing elements or otherwise modifying a state of the stream application, a debugging application and stream manager may modify data flows within the application stream in a variety of ways to minimize any disruption resulting from a debugging session.

Abstract: A technology is described for debugging in a cluster processing network. A scheduler can dispatch a process that is part of the cluster job for execution. Further, a compute node can be used to execute the process dispatched by the scheduler to the compute node. A debugger can be activated in response to an unhandled suspension event in the process on the compute node. In addition, the debugger can send notification messages regarding the unhandled suspension event. A job monitor can receive a notification from the debugger that an unhandled suspension event has occurred. The notification can be displayed to a user via the job monitor.

Abstract: 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.

Abstract: In one embodiment, a method includes determining an execution plan of a plurality of blocks in an application. The execution plan defines a structure for execution of blocks in the plurality of blocks. A debugging command is received in a debugger. An active block in the structure defined in the execution plan. A computing device performs a block level action on the active block.

Abstract: Predicate checking in conjunction with distributed systems can enable an investigating user to check predicates in the context of instance states and/or distributed states of a distributed system. In an example embodiment, a method entails accepting distributed system simulation data and performing a simulation of a distributed system using the distributed system simulation data to create distributed system simulated states. At least a portion of the distributed system simulated states are exposed. The exposed portion of the distributed system simulated states is retrieved and stored as exposed states for the distributed system. The exposed states for the distributed system are compared to predicate states for the distributed system. If an inconsistency is detected between the exposed states and the predicate states based on the comparing, at least one alarm is issued.

Abstract: Systems and methods consistent with the invention may include displaying, during debugging of source code having corresponding executable code, a screen including a first section, wherein a variable name included in the source code is displayed in a first format in the first section, receiving a user selection of the variable name, converting, by using a processor, the first format of the variable name to a second format in response to the received selection, wherein the variable name includes a plurality of characters and converting the first format of the variable name to the second format includes converting the characters to uppercase, searching for a corresponding variable name in the executable code, and displaying, on the display device, a second section including the corresponding variable name, wherein the variable name is displayed in a third format in the second section.

Abstract: Debugging operations on individual client sessions for a remotely executed shared application are enabled to be performed as the client requests are processed on the executing server without disrupting execution of other client sessions. A remote debugging client may connect to a debugging engine executed on the server allowing the debugging client to view source code, set breakpoints, view client connections, and receive callbacks or notifications when a breakpoint is hit by the client session being debugged. The debugging client may also control execution by stepping through client code enabling debugging of multiple clients simultaneously.

Abstract: A coverage analysis tool may determine coverage in respect to heterogeneous coverage tasks associated with different hierarchy levels of a tasks hierarchy. The coverage analysis tool may iteratively refine coverage tasks to determine coverage of sub-tasks. In some cases, coverage tasks may be unrefined in order to reduce overhead of coverage analysis in performance of the software under test, such that the software under test may perform in an essentially similar manner as in non-testing mode.

Abstract: A system comprises built-in self-test (BIST) logic configured to perform a BIST, processing logic coupled to the BIST logic and storage logic coupled to the processing logic. The storage logic comprises debug context information associated with a debugging session. Prior to performance of the BIST, the processing logic stores the debug context information to a destination. After performance of the BIST, the processing logic is reset, and the processing logic restores the debug context information from the destination to the storage logic.

Abstract: Predicate checking in conjunction with distributed systems can enable an investigating user to check predicates in the context of instance states and/or distributed states of a distributed system. In an example embodiment, a method entails accepting distributed system simulation data and performing a simulation of a distributed system using the distributed system simulation data to create distributed system simulated states. At least a portion of the distributed system simulated states are exposed. The exposed portion of the distributed system simulated states is retrieved and stored as exposed states for the distributed system. The exposed states for the distributed system are compared to predicate states for the distributed system. If an inconsistency is detected between the exposed states and the predicate states based on the comparing at least one alarm is issued.

Abstract: A programming language support for debugging heap related errors includes one or more queries for determining one or more global properties associated with use of the area by the program. The one or more queries may be executed in parallel or concurrently and dynamically utilize available number of cores.

Abstract: A debugger includes: a plurality of processor cores; and a scheduler configured to control an allocation of a plurality of basic modules to the processor cores based on an execution rule for enabling parallel execution of a program that is divided into the basic modules that are executable asynchronously with one another, the program being defined with the execution rule of the basic modules for executing the basic modules in time series, wherein the scheduler includes a break point setting module configured to set a group of break points that are designated through a graphical user interface.

Abstract: A method, apparatus, system, article of manufacture, and data structure provide the ability to debug a map-reduce application on a cluster. A cluster of two or more computers is defined by installing a map-reduce framework (that includes an integrated development environment [IDE]) onto each computer. The cluster is formatted by identifying and establishing communication between each computer so that the cluster functions as a unit. Data is placed into the cluster. A function to be executed by the framework on the cluster is obtained, debugged, and executed directly on the cluster using the IDE and the data in the cluster.

Abstract: An embodiment relates generally to an apparatus for debugging. The apparatus includes a memory configured to store data and an arithmetic logic unit configured to perform logical and arithmetic operations. The apparatus also includes a control unit configured to interface with the memory and arithmetic logic unit and to decode instructions. The control unit is configured to write a data state designated to be overwritten by a currently executing instruction to a buffer allocated in the memory in response to a trace debug flag being set.

Abstract: A method for debugging the program of operational software of an onboard system, including flagging the program by positioning flags along an execution path for dividing the aforementioned execution path into adjacent functional intervals; normal execution of the program; acquiring an execution condition of the program by flag condition vectors; when an error is detected, searching a faulty functional interval based on the flag condition vectors, reverse execution of the program in the aforementioned faulty functional interval, and determination and correction of the error.

Abstract: Conventionally, when executing a plurality of programs while being synchronized by a plurality of debuggers, an interface has been required for performing a particular coordination between the debuggers. In the present invention, programs are synchronously executed without coordination between the debuggers by performing a control method including a step for maintaining a program execution state in the debuggers to be different from an actual program execution state, so that the program execution is retained, if necessary, in response to a program execution request from a debugger.

Abstract: An exception notification system is described herein that provides an early notification that a software exception has occurred before exception handling code has run. The exception notification system receives a registration request from program code to register a handler to receive an early notification when an exception occurs. When an exception occurs, the system raises an event that calls each registered handler. After the handler returns, the system performs normal exception handling, so that the early notification does not change existing exception-handling behavior. The exception notification system allows a program to inspect and log an exception before the program state has been modified by exception handling. The program code can capture detailed information about the cause of the exception to enable further offline analysis. Thus, the exception notification system allows developers to improve their programs by receiving more information about unexpected conditions in the program code.

Abstract: A method of debugging a function upon function exit includes pausing program execution at the time of initializing the function, wherein the function initialization includes saving a set of registers on the stack, recording the value of the stack pointer, configuring a watchpoint register based on the recorded value, wherein the watchpoint register is configured to trap memory references of the function based on the recorded value of the stack pointer, and executing the function. Program execution will pause when it is exiting the function because of stack references made by the function epilogue to restore registers saved on the stack and the configured watchpoint registers.

Abstract: The invention relates to a data processing system comprising a central processing unit, a first memory coupled to the central processing unit for storing variable data values, an eventing engine coupled to the central processing, a debug module coupled to the central processing unit and to the eventing engine for receiving the variable data values by way of the eventing engine in real time and configured to trigger breakpoints; and an interface to connect to an external device. Both event-based variable watching and debugging can occur contemporaneously by a user using an external device connected to the interface.

Abstract: A low privilege debug pipeline publisher advertises a debugging pipeline. Instead of having a client to which a debugger on the server has been attached interrogate the server for debugging information, the client requests information from the server. Control is returned to the server which can refuse to provide the requested information to the client. A debuggee server executes client code being debugged in an isolated context so that pausing the code at a breakpoint does not block the server. The server can apply transforms to compiled code to make the code cooperate with debugging services so that a privileged component to inspect the debuggee code is not needed.

Abstract: A processor, a multiprocessor, and a debugging method for solving the conventional problems, one of which is very difficult to switch among debug programs and start the selected program within a certain time. The above convention problem can be solved by a processor that includes a debug unit block, a multimode debug interrupt control block, and an execution block. The debug unit block monitors the execution of the debug target user program and issues a debug interrupt when a predetermined debug condition is satisfied. The control block, upon receiving such a debug interrupt, specifies a debug mode that selects a predetermined debug program. When the debug unit block issues such a debug interrupt, the execution block selects and executes a debug program according to the debug mode specified by the control block.

Abstract: The method executes the application and if there are no errors from the execution of the application, the method ends. If errors exist, the errors are collected from the execution of the application in an error report. Labeled application paths are created by adding a unique label to individual application paths where the application paths are individual loops and individual functions in the application. An analysis is created of the labeled application paths by executing the application with the labeled paths, reviewing the error report for data related to the labels and if an error is sufficiently related to application paths with labels, storing the path that created the errors in a report. If an error is not sufficient related to the application path with labels, the method is repeated by the creating the analysis again by substituting additional application paths for the application paths.

Abstract: A method and a system for providing customizable, process-specific Just-In-Time debugging in operating system is provide in this invention. The method comprises the following steps: obtaining process-specific JIT debugging information, in response to the occurrence of an trap event in operating system; invoking the debugger corresponding to the process according to the obtained process-specific JIT debugging information. This method and system supports per-process JIT debugging configuration.

Abstract: A messaging system based group joint debugging system is provided, comprising a master computer and a slave computer in mutual communication with the master computer through network. With the group joint debugging system, multiple members of a geographical distributed development team can do jobs on a same debugging session. The master computer includes capabilities for obtaining a debugging request message containing a debugging command via the messaging system, extracting the debugging command and calling a corresponding debugging function of the program debugger according to the debugging command, and sending execution result of the called debugging function, as a debugging response message, to computers participating in a group joint debugging, such that the group joint debugging is carried out to the program to be debugged. The slave computer includes capabilities for receiving the debugging response message and carrying out automatic debugging on the program according to the debugging command.

Abstract: Various technologies and techniques are disclosed for providing a debugger for programs running under a transactional memory system. When running a particular program using the debugger, the system detects when a conflict occurs on at least one conflictpoint that was set in the particular program. A graphical user interface is provided that displays information related to the detected conflict. The graphical user interface can display transactional state and/or other details independently of a conflict. A conflictpoint can be assigned to one or more regions of source code in one or more transactions in the particular program. A conflictpoint can also be assigned to a particular variable in the particular program. When running the particular program in a debug mode, execution is stopped if a conflict occurs on any of the conflictpoints.

Abstract: Various technologies and techniques are disclosed for performing configuration debugging comparisons. Snapshots are acquired from at least two computer systems to be compared. The snapshots from the computer systems are then compared. Heuristics are used to determine which differences are actually logically equivalent and thus not to be identified as differences. Comparison results are generated and then displayed in a manner that allows a user to see one or more differences identified between the systems. A filtering feature is provided to allow the user to further filter the comparison results based on a type of issue to be diagnosed. A requirements feedback feature is provided to allow the user to add a user-identified difference as a configuration requirement to a system model.

Abstract: The present disclosure provides methods and apparatuses for debugging a workflow. Using the methods and apparatus herein, users can utilize common debugging constructs such as watch variables, step into/over and call stack. This allows users to visually debug all elements of process design, not just code snippets, at design time before the process is deployed.

Abstract: A debug interface is disclosed that is operable to receive diagnostic signals from a host debugger, amend the diagnostic signals and send the amended diagnostic signals to a virtual machine operable to process a plurality of applications in parallel. The debug interface comprises: at least one port corresponding to at least one of said plurality of applications; and diagnostic signal processing logic; wherein said at least one port is operable to receive a diagnostic signal from said host debugger, said diagnostic signal specifying a diagnostic operation to be performed on an application running on said virtual machine; and said diagnostic signal processing logic is operable to determine which of said plurality of applications said received diagnostic signal pertains to in dependence upon said at least one port said diagnostic signal was received at, and to amend said received diagnostic signal to identify said application prior to sending said amended diagnostic signal to said virtual machine.