Abstract: Disclosed are a fault management method and apparatus. The method includes: an M2M gateway receiving a fault management task sent by an M2M service platform; and the M2M gateway executing the fault management task. The fault management apparatus, applied to a machine to machine (M2M) gateway, comprises: a task receiving module, configured to: receive a fault management task sent by an M2M service platform; and an executing module, configured to: execute the fault management task. The fault management method and apparatus of the present document can be used to realize the M2M platform fault management and solve the M2M platform fault monitoring problem.

Abstract: An illustrative method for identifying information associated with a ring of individuals performing improper financial activities may include combining a list of user identifiers with one or more attributes tables corresponding to the financial transactions. A computer device may analyze a first list of identifiers in relation to an attribute table, where the identifiers may be associated with one or more suspected improper financial activities and the attribute table may include attributes of one or more financial transactions performed over a specified duration. The computer device may then link the first list of identifiers with one or more attributes included in the attribute table to determine a second list of identifiers and the process may be repeated until a stopping condition has been reached. After the stopping condition has been met, the computer device may communicate a report to a user.

Abstract: A diagnostic service can be provided for devices that include a device agent for allowing the devices to be managed. The diagnostic service can operate on a managed device to monitor and manage the device agent. To facilitate communication between the management server and the diagnostic service, the diagnostic service can obtain connection information and an authentication code from the device agent after the device agent has registered with the management server. The diagnostic service can then employ the connection information and authentication code to register with the management server. Once the diagnostic service is registered, the management server can employ the diagnostic service to monitor and manage the device agent.

Abstract: A method for filtering multiple in-memory trace buffers for event ranges is provided. The method includes allocating a plurality of main trace buffers, based on the number of central processing units (CPU) participating in a trace. Each CPU has a dedicated main trace buffer, and each main trace buffer is circular. Each main trace buffer is divided into an equal number of sub-buffers. A plurality of events is written to the current sub-buffer. When the current sub-buffer is filled, events are written to the next sub-buffer. Events are extracted from at least one of the sub-buffers, starting with the sub-buffer that includes a compare time and ending at the end of the main trace buffer.

Abstract: A system may obtain an executable code segment of program code. The executable code segment may be associated with an emitter, and the program code, when executed, may be associated with a plurality of execution states. Each execution state, of the plurality of execution states, may correspond to a state of execution at a point in the execution of the program code that causes an event, of the plurality of events. The system may execute the executable code segment. The system may receive, from the emitter and based on executing the executable code segment, a program state corresponding to the particular execution state. The emitter may emit the information based on a particular event caused by executing the executable code segment. The system may collect the program state and information describing the particular event.

Abstract: A user terminal and a driving method thereof, a control device and a driving method thereof, and a control system of a controlled device are provided. The user terminal includes: a communication interface configured to communicate with a plurality of controlled devices which are operated based on individually set setting values; a user interface configured to receive an adjustment value for collectively controlling the plurality of controlled devices as a group; and a controller configured to individually adjust each of the setting values based on a ratio which relates to the received adjustment value, and to control the plurality of controlled devices based on the adjusted setting values.

Abstract: A system, method, and computer program product are provided for identification of common root causes with sequential patterns. In use, a plurality of customer event sequences are identified. Additionally, the plurality of customer event sequences are grouped into a hierarchical framework of patterns. Further, a root-cause analysis (RCA) is performed for the customer event sequences utilizing the hierarchical framework of patterns.

Abstract: A user-mode crash reporting system for generating a crash report when an application crashes is provided. The user-mode crash reporting system installs a crash handler to execute in the same process as the application when the application crashes. When the application crashes, the crash handler identifies a victim thread of the process that was executing at the time of a crash. The crash handler then walks a call stack of the victim thread to identify return addresses for returning from called functions of the application. The crash handler identifies offsets within the module corresponding to the return addresses and creates a call chain of functions using the identified offsets. The crash handler then generates a crash report based on the identified call chain.

Abstract: One or more problems may be detected in an executing application by retrieving runtime execution information from the application executing on one or more computers. The runtime information is transformed into a temporal sequence of events. A knowledgebase is searched for a dialog that has nodes in an order that match the temporal sequence of events according to a threshold degree. Responsive to finding the dialog in the knowledgebase, the dialog is launched on a user interface to interact with a user and guide the user through a problem identification and solution. Responsive to not finding the dialog, additional instrumenter is enabled in the application.

Abstract: One or more problems may be detected in an executing application by retrieving runtime execution information from the application executing on one or more computers. The runtime information is transformed into a temporal sequence of events. A knowledgebase is searched for a dialog that has nodes in an order that match the temporal sequence of events according to a threshold degree. Responsive to finding the dialog in the knowledgebase, the dialog is launched on a user interface to interact with a user and guide the user through a problem identification and solution. Responsive to not finding the dialog, additional instrumenter is enabled in the application.

Abstract: Systems and methods for profiling application code are disclosed. The method is hybrid in nature as it may include inserting instrumentation within application code and also periodic sample gathering, by employing a runtime app profile generator that provides the hybrid profiling infrastructure and is linked to the application code. An executable user application is then generated from the application code, and the executable user application is executed. The runtime app profile generator is then launched in response to the execution of the application code, and hybrid profiling results are generated by obtaining samples from the different threads of the executed application code and accumulating instrumented execution information. In some implementations, the hybrid profiling results capture even cold regions of the code and can also be used for a next round of profiling through automated targeted instrumentation.

Abstract: In general, a value of a numerical attribute of a record stored in a data structure is received. A numerical range is generated that includes the value of the numerical attribute. An entry is stored, in an index associated with the data structure, that specifies a location of the record within the data structure and that includes a first index key and a second index key. The first index key corresponds to a value of an attribute of the record different from the numerical attribute, and the second index key corresponds to the generated numerical range.

Abstract: Embodiments relate to address probing for a transaction. An aspect includes determining, before starting execution of a transaction, a plurality of addresses that will be used by the transaction during execution. Another aspect includes probing each address of the plurality of addresses to determine whether any of the plurality of addresses has an address conflict. Yet another aspect includes, based on determining that none of the plurality of addresses has an address conflict, starting execution of the transaction.

Abstract: Embodiments relate to address probing for a transaction. An aspect includes determining, before starting execution of a transaction, a plurality of addresses that will be used by the transaction during execution. Another aspect includes probing each address of the plurality of addresses to determine whether any of the plurality of addresses has an address conflict. Yet another aspect includes, based on determining that none of the plurality of addresses has an address conflict, starting execution of the transaction.

Abstract: A monitor that monitors an application is provided herein. The monitor provides a monitor function that monitors an application. The monitor embeds the monitor function in meta data of a code base of the application. The monitor function embedded in the code base is activated. The monitor function is used to monitor data associated therewith during deployment of the application.

Abstract: A technique for testing software includes monitoring whether a predefined event occurs in a software test instance. In response to occurrence of the predefined event, different types of snapshots of the software test instance are generated according to a property of the event. The snapshots are used to record a state of the software test instance when the predefined event occurs. The different types of snapshots are stored in information related to the predefined event.

Abstract: Computer system including storage unit and processing unit including performance monitoring unit (PMU) for performance monitoring on tasks is provided. Processing unit is configured to provide a callback function at location at which a task switch is being performed, reset a counter for external access counting of PMU when first task switch which is to switch execution of tasks to first task occurs, read counted value from counter and record read value into a log of storage unit as record of first task when second task switch which is to switch execution of tasks from first task to second task occurs, and reset counter for second task after log is generated. Records of first task in log within a predetermined time period are summed to analyze performance of first task within predetermined time period so as to determine performance of external access of first task for specific event.

Abstract: Systems and methods provide a debugger that debugs code using two versions of code, an optimized and a debuggable version of object code for subroutines, methods or functions. The debugger causes the appropriate version of the code to be executed depending on whether debug commands have been applied with respect to particular subroutines, methods or functions.

Abstract: A method for easily tracing the execution of an application in a computer system having a plurality of computing nodes interconnected by high speed data links is disclosed. While executing the application on one or more of the computing nodes, trace data is collected into a separate temporary trace buffer coupled to each computing node. A trace transfer request event is sent to another one of the computing after collecting a portion of the trace data in one of the trace buffers. The trace data is recorded on a designated recording and analysis computing node by transferring the trace data from each trace buffer to a recording buffer in the designated computing node in response to the transfer request by performing memory mapped read transfers initiated by the designated computing node. Each trace buffer is memory mapped into an address space of the second computing node.

Abstract: Autonomous media version testing is described. A method may include testing, by a processing device of a server and without human interaction, a plurality of versions of a game, each having a different set of test conditions, using information received from play of the plurality of versions of the game after a first game move has been made in the game. The method may also include determining, by the processing device and without human interaction, which of the plurality of versions of the game to publicly release based on the testing.

Abstract: Techniques are described for a run to end of execution pattern in a software debugger. In one example, a method includes identifying a pattern of stop events in a program. The method further includes executing the program in a debugger, wherein executing the program includes encountering a stop event, determining if the stop event is part of the pattern of stop events, and ignoring the stop event in response to determining that the stop event is part of the pattern of stop events.

Abstract: A network processor includes a cache and a several groups of processors for accessing the cache. A memory interconnect provides for connecting the processors to the cache via a plurality of memory buses. A number of trace buffers are also connected to the bus and operate to store information regarding commands and data transmitted across the bus. The trace buffers share a common address space, thereby enabling access to the trace buffers as a single entity.

Abstract: Systems and techniques are described for tracking software code paths. A described technique includes receiving a first log of stack traces that includes a respective stack trace for each of a plurality of calls to access any of a plurality of data objects created during a first execution of an application, generating, for each of the stack traces in the first log, a script for a respective probe that identifies the data object accessed by the call corresponding to the stack trace, a respective instruction called to access the data object, and whether the access is a read or a write access for the data object, generating, for at least one of the probes, a second log that identifies the data object for the respective probe and the data stored in the data object, and generating a representation of the execution of the application using the second log.

Abstract: Error logs, bug reports, and other databases identifying problems with a tracer system may be mined to determine how a tracer may interact with a given function, module, or other group of functions. Based on such reports, a tracer may be configured to avoid certain functions or to trace such functions in a specific manner. In some cases, tracer may be configured to limit tracing to certain parameters or with other limitations to avoid any known conditions under which errors occur.

Abstract: A performance monitoring and management system is provided for monitoring both server side and network side performance parameters of individual distributed transactions. The system uses correlation data which is transferred over a computer network to identify corresponding sender/receiver parts of a distributed transaction. Both server side tracing data and correlation data is transferred to an external correlation and monitoring server that creates per transaction end-to-end tracing data. Network probes are installed in the network infrastructures which monitor network conditions, like e.g. data transferred. Those network probes are configured in a way to identify and extract the correlation data used by the monitoring system and to tag created network measurements with this correlation data. Those tagged network measurements are then used to augment the per transaction end-to-end tracing data with corresponding network measurements.

Abstract: A computing system intercepts a message generated by an application at runtime. The message has content to be logged in a log data store. The computing system identifies sensitive information in the message content and modifies the message content to protect the sensitive information. The computing system causes the modified message content to be logged in the log data store.

Abstract: A system for software development includes a central server comprising a revision control system module; a process server including a process tool module; a local server including a local development environment; and an integration server including a mapping module. The revision control system module includes a plurality of branches. The process tool module is configured to create a ticket indicating a product requirement. The central server is configured to maintain and update the ticket that variably associates the development artifact with a respective one of the branches of the revision control system module. The integration server is configured to copy changes in the ticket stored on the revision control system to the ticket in the process tool module, and accordingly control transitions of the development artifact between the plurality of branches in the revision control system module of the central server.

Abstract: A system and method for debugging an executing program. The method includes executing a general-purpose computing on graphics processing units (GPGPU) program. The GPGPU program comprises a first portion operable to execute on a central processing unit (CPU) and a second portion operable to execute on a graphics processing unit (GPU). The method further includes attaching a debugging program to the first portion of the GPGPU program and modifying the first portion of the GPGPU program. The attaching of the debugging program to the first portion of the GPGPU program pauses execution of the first portion of the GPGPU program. The method further includes resuming execution of the first portion of the GPGPU program and accessing a first state information corresponding to the first portion of the GPGPU program. Execution of the first portion of the GPGPU program may then be paused.

Abstract: A stateful rules verification platform is described that support timed state transitions. The verification platform implements a specification language to provide a formal definition for rules used to test target systems having a central module that provides APIs (“API provider”) and applications (“API clients”) that use the APIs. Rules may be defined in terms of transitions on state elements associated with interactions between API providers and API clients. The rules defined in accordance with the specification language enable run-time verification in which calls may be intercepted and run-time code to implement checks may automatically be generated and injected to test behaviors of the intercepted calls. The same set of rules may also be employed for static verification during compilation. Additionally, the specification language includes constructs to specify timed state transitions for at least some rules that impose time limits on state transitions specified by the rules.

Abstract: Systems, methods, and media for detecting the presence of return-oriented programming (ROP) payloads are provided, comprising; identifying a potential gadget address space; determining if a piece of the data corresponds to an address of the potential gadget address space; and in response to determining that the piece of the data corresponds to an address of the potential gadget address space: determining whether a plurality of operations, each associated one of a plurality instructions beginning at the address, indicates that an ROP payload is present in the data, and indicating that an ROP payload is present in the data in response to making a determination that a plurality of operations indicates that an ROP payload is present in the data a given number of times.

Abstract: This invention provides a new mechanism for “Hot-Tracing” using a novel placeholder mechanism and binary rewriting techniques, which leverages existing compiler flags in order to enable light-weight and highly flexible dynamic instrumentation. Broadly, I-Probe can be divided in 2 distinct workflows—1. Pre-processing (ColdPatch), and 2. Hot Tracing. The first phase is a pre-processing mechanism to prepare the binary for phase 2. The second phase is the actual hot-tracing mechanism, which allows users to dynamically instrument functions (more specifically symbols) of their choice.

Abstract: For data integration using APIs, a request for data is analyzed to determine a set of functional characteristics and a set of non-functional characteristics expected in the data. A first API entry is selected in a registry of API entries, the first API entry corresponding to a first API of the first data source. The first API entry includes a first metadata corresponding to a first functional characteristic in the set of functional characteristics. The first API is invoked to obtain a first portion of the data, the first portion having the first functional characteristic. Using a second API entry in the registry, a second API is invoked to obtain a second portion of the data. The first portion and the second portion are returned in a response to the request.

Abstract: A method and a device for signing a program crash are disclosed, which are applied to the filed of communication technology. The device for signing the program crash firstly acquires stack information invoked when the program crash occurs during executing a process of an application program by a computer system, then acquires first stack information corresponding to the process of the application program from the acquired stack information, and signs the occurred program crash based on the first stack information.

Abstract: To provide a visual representation of a sub-set of a visual program generated using a visual programming tool, wherein a trace operation is executed against the visual program and resulting trace data is stored in a trace file, an apparatus includes a parser for parsing the trace file to obtain the trace data, and a generator for using event data associated with an event and associated component data associated with a component of the visual program to generate render data. The event data and the component data are associated with the trace data.

Abstract: An analysis and visualization is used to depict how a concurrent application executes threads on processor cores over time. With the analysis and visualization, a developer can readily identify thread migrations and thread affinity bugs that can degrade performance of the concurrent application. An example receives information regarding processes or threads running during a selected period of time. The information is processed to determine which processor cores are executing which threads over the selected period of time. The information is analyzed and executing threads for each core are depicted as channel segments over time, and can be presented in a graphical display. The visualization can help a developer identify areas of code that can be modified to avoid thread migration or to reduce thread affinity bugs to improve processor performance of concurrent applications.

Abstract: A method for executing a machine code based on a dynamic language is disclosed. An execution guard is created as a value stored in a data structure. The value is representative of an expected condition or a set of conditions for a reusable portion of the machine code. The value representative of the expected condition(s) is compared to an actual value encountered later during execution of a portion of the machine code. The reusable machine code is executed if the actual value corresponds with the value representative of the expected condition(s). The execution guard is invalidated if any of the expected conditions changes.

Abstract: A method for obtaining accurate call path information in a mixed-mode environment where interpreted methods and non-interpreted methods can call one another is disclosed. In one embodiment, such a method includes generating an event and recording it in a buffer when an interpreted method calls an interpreted method. The method also generates an event and records it in the buffer when an interpreted method calls a non-interpreted method. The method further generates an event and records it in the buffer when a non-interpreted method calls an interpreted method. The method refrains from generating an event when a non-interpreted method calls a non-interpreted method. A corresponding apparatus and computer program product are also disclosed.

Abstract: Embodiments of translation verification testing are provided. An aspect includes reading a symbol table and a syntax tree to which source code corresponds. Widget objects and widget object methods are obtained in the symbol table. The widget objects and widget object methods are organized into a widget structure tree according to a code calling order in the syntax tree. An index file corresponding to the source code is generated by using the symbol table, the widget structure tree and resource files, where the index file records relationships between the widget objects.

Abstract: Embodiments relate to fingerprint-based processor parameter management. An aspect includes determining a fingerprint of software that is currently executing on a processor of a computer system, the fingerprint comprising a representation of a sequence of behavior that occurs in the processor while the software is executing. Another aspect includes determining whether the fingerprint is listed in a fingerprint table with an associated operating parameter value. Another aspect includes based on determining that the fingerprint is listed in the fingerprint table, setting an operating parameter in a parameter register of the processor equal to the associated parameter operating parameter value. Another aspect includes based on determining that the fingerprint is not listed in the fingerprint table: determining a value for operating parameter during execution of the software; and setting the operating parameter in the parameter register equal to the determined value.

Abstract: Methods, systems and computer program products for high performance data streaming are provided. A computer-implemented method may include receiving a data mapping describing an association between one or more fields of a data storage location of a data source and one or more fields of a data storage location of a target destination, generating a data transfer execution plan from the data mapping to transfer data from the data source to the target destination where the data transfer execution plan comprises a determined degree of parallelism to use when transferring the data, and transferring the data from the storage location of the data source to the data storage location of the target destination using the generated data transfer execution plan.

Abstract: Aspects of the subject disclosure are directed towards monitoring application performance during actual use, particularly mobile application performance. Described is instrumenting mobile application binaries to automatically identify a critical path in user transactions, including across asynchronous-call boundaries. Trace data is logged by the instrumented application to capture UI manipulations, thread execution, asynchronous calls and callbacks, UI updates and/or thread synchronization. The trace data is analyzed to assist developers in improving application performance.

Abstract: For use in a data processing system comprising a processor configured to execute a first set of instructions corresponding to a first thread and a second set of instructions corresponding to a second thread, a method is provided. The method comprises in response to execution of a debug related instruction by the first thread while executing the first set of instructions, generating a debug event for processing by the second thread, wherein processing the debug event comprises causing a halting operation related to the processor.

Abstract: Methods and systems for software testing with feedback acquisition are disclosed. Modified program code is generated based on programmatic analysis of original program code. The modified program code includes the original program code and a plurality of additional instructions. The additional instructions implement user interface prompts soliciting answers to user feedback questions. The modified program code is sent to one or more client devices for execution. User input responsive to the user interface prompts is then received from the one or more client devices.

Abstract: A method for obtaining accurate call path information in a mixed-mode environment where interpreted methods and non-interpreted methods can call one another is disclosed. In one embodiment, such a method includes generating an event and recording it in a buffer when an interpreted method calls an interpreted method. The method also generates an event and records it in the buffer when an interpreted method calls a non-interpreted method. The method further generates an event and records it in the buffer when a non-interpreted method calls an interpreted method. The method refrains from generating an event when a non-interpreted method calls a non-interpreted method. A corresponding apparatus and computer program product are also disclosed.

Abstract: A system according to an embodiment is configured to display program execution results with respect to a common axis. The system includes a first unit that acquires event information about two or more events, acquires reference-event identification information to be used in identifying reference events, and generates event objects which represent the events, and a second unit that acquires axis information which represents information about the common axis. The event information contains timing information indicating positions of the events. The first unit sets the reference events as references for the program execution results based on the acquired reference-event identification information, determines display positions of the reference events with respect to the common axis to be same position based on timing information in event information about the reference events, and generates event objects representing the reference events based on the determined display positions with respect to the common axis.

Abstract: Provided are a computer program product, system, and method for embedding and executing trace functions in code to gather trace data. A plurality of trace functions are embedded in the code. For each embedded trace function, a trace level is included indicating code to which the trace applies. The trace level comprises one of a plurality of levels. During the execution of the code, the embedded trace functions having one of the levels associated with a specified at least one level specified are executed. The embedded trace functions associated with at least one level not comprising one of the at least one specified level are not invoked.

Abstract: Systems and methods for process flow tracking are presented. In one embodiment, a flow method comprises collecting records associated with flow for post analysis; performing a flow connection process associated with the flow, wherein the flow connection process examines information in a hash table and connects flow segments based upon connect ID; and performing a presentation process in which the flow is visualized, searched and traversed. In one exemplary implementation, a flow connection process utilizes a hash table that draws a correlation between the connect ID and a connect-start record or a connect-end record.

Abstract: A data processing apparatus is provided with trace circuitry for generating a plurality of trace streams including an instruction trace stream 10 and a data trace stream 12. The instruction elements within the instruction trace stream and the data elements within the data trace stream are marked with key values KV such that a match may be made between data elements and corresponding instruction elements. When predetermined conditions are met, synchronization markers 66 are inserted in both the instruction trace stream 10 and the data trace stream 12 in order to permit a precise correlation to be made between the instruction elements and the data elements when the data is subsequently analyzed.

Abstract: A program code execution is monitored. Variable type and value information the one or more variables in the program code take during the execution of the program code are stored, and compiled over multiple execution of the program code as historical run-time execution traces. A code editor user interface may present the historical run-time execution traces for inspection, whether or not the program code is currently executing. Statistical properties associated with the variable type and value information may be computed. Future variable type and value the one or more variables might take during future execution of the program code may be predicted.

Abstract: A method of establishing traceability for embedded software systems. A design code database is provided for an embedded software system. A test suite database including a plurality of test cases is structured for testing design code of the embedded software system. The structuring of the test cases provides a correspondence from a respective test case to a respective portion of the design code. A processor receives a design code modification to the embedded software. An associated test case is identified for testing the modified design code being based on traceability data. The associated test case is revised to accommodate the modified design code. The modified test cases are integrated into the test suite. A traceability database establishes a one-to-one correspondence between the modified design coder and the modified test case is updated.