Abstract: A hooking system for hooking predetermined references to predetermined dynamically loaded library (DLL) functions includes a DLL version identifier provided by a hook entry code to an enhanced hook. The hook entry code is dynamically generated during runtime of an affected software application. The version identifier enables unambiguous communication of a single enhanced hook with functions of multiple versions of identically named DLLs loaded into the same isolated process memory area.

Abstract: A performance, analytics and auditing (PAA) system is configured to operate with a complex web application including a portal application and its sub systems non-intrusively. The PAA system includes a first component configured to capture behavior-related information from the portal application, a second component configured to capture performance-related information from the portal application, a third component configured to capture auditing-related information from the portal application. The PAA system is further configured to start or stop with minimal impact on the portal application, wherein the PAA system is coded using Aspect Oriented Programming (AOP) and able to collect information from multiple threads.

Abstract: Embodiments provide systems, methods, and computer program products for monitoring application performance in multithreaded environments. Monitoring data may be inserted into data structures that propagate and persist between threads involved in a processing event. Data related to specific methods executing on each thread may be output to a trace file. The trace file may be analyzed for application performance by associating the threads that contain the same tracking data from the propagated data structure.

Abstract: A system is configured to receive, from a user device, a request for content; obtain, based on receiving the request, an identifier for a subscriber associated with the system and a key; encode the identifier and the key to create a unique identifier; store the unique identifier in the request to create a modified request; provide the modified request to a content provider identified by the request; receive, from the content provider, the content and targeted content, the targeted content being associated with the unique identifier and conforming to an attribute of the subscriber; and provide, to the user device, the content and the targeted content.

Abstract: The present invention is a technique for obtaining execution frequency information on execution paths in a CFG, including preparing a CFG from a source code read into a memory, preparation of the CGF including modifying the CFG by assigning path value zero to an edge v?w between a precedent basic block v and a successor basic block w following the predecessor basic block v in a case where the successor basic block w has a predecessor basic block x other than the predecessor basic block v, and where the successor basic block w exists on a fall-through path from the predecessor basic block x. The technique also includes obtaining execution frequency information by using the modified CFG.

Abstract: Methods for accessing hardware resources in an electronic device with a browser-based operating system (OS) which includes a user interface running in a browser are provided. A local server is first provided on the electronic device, wherein the local server has a corresponding URL and a dedicated network port. Then, upon receiving a service request from the client-side web application, the local server analyzes a service type of the service request and performs an operation to at least one of the hardware resources corresponding to the service type, wherein the service request is generated and directed to the local server according to the URL and the dedicated network port of the local server by the client-side web application on the electronic device.

Abstract: Code to be modified is identified and modified by a dynamic code optimizer (DCO) or other optimizer executing in the same or different address space as the application being modified. The modified code is stored in memory regions separate from the memory regions of the unmodified or pre-existing code. This allows instruction fetches by the application to access the modified code, while data accesses by the application access the unmodified code. An optimizer may also access the code, but accesses by the optimizer are considered data accesses, and therefore, such accesses would be to the unmodified code, instead of the modified code. Thus, an address mapping capability is provided in which the optimizer may access the modified code by having multiple addresses point to the same physical memory location. One address is used by the application in an instruction fetch and the other address is used by the optimizer in a data access to access the modified code.

Abstract: A graphic visualization layer in an interactive development environment is displayed and used to create an application on a node of a computer network. The graphic visualization layer includes graphical shapes manipulated by a user to generate program language code for lifecycle stages of the application. The graphical shapes include an application graphical shape representing the application, a resource graphical shape representing a resource for the application, an action graphical shape representing an action for the application and a task graphical shape representing a task of the action. A selection of the application graphical shape is received. An application value for the application is received in an entry field of the application graphical shape. Program language code is generated based on the selection of the application graphical shape and the application value. The program language code is executable to install the application on a node of the computer network.

Abstract: Provided is a memory management method, and an apparatus to perform the method, which achieves a shortened user waiting time in consideration of system performance. The method includes acquiring a deallocation unit used to deallocate an allocated memory area according to at least one attribute, and deallocating the allocated memory area using the deallocation unit.

Abstract: A method of receiving a stack trace, where the stack trace refers to executed code that crashed; identifying one or more lines of the executed code that caused the executed code to crash; identifying, from a code repository, contact information of a developer from a plurality of developers that are responsible for the executed code, where the developer is responsible for a code commit that refers to the one or more lines of the executed code; and notifying, through the contact information, the developer that the one or more lines caused the executed code to crash.

Abstract: The present disclosure relates to malware and, more particularly, towards systems and methods of processing information associated with detecting and handling malware. According to certain illustrative implementations, methods of processing malware are disclosed. Moreover, such methods may include one or more of unpacking and/or decrypting malware samples, dynamically analyzing the samples, disassembling and/or reverse engineering the samples, performing static analysis of the samples, determining latent logic execution path information regarding the samples, classifying the samples, and/or providing intelligent report information regarding the samples.

Abstract: A method for detecting foreign code injected into a computer system including a processor and memory, the processor being configured to execute instructions stored in the memory, includes: detecting, on the computer system, an illegal instruction error; recording the illegal instruction error; determining whether a threshold condition is met; and generating an alert if the threshold condition is met.

Abstract: Testing computer software applications by performing a first black-box test on a computer software application, identifying any instructions of the computer software application that were reached by a payload of the first black-box test, determining a degree of success of the first black-box test in accordance with predefined success criteria, determining whether any of the instructions that were reached by the payload changed after performing the first black-box test, deciding whether to perform a second black-box test on the computer software application, where the deciding whether to perform the second black-box test is based on whether any of the instructions that were reached by the payload of the first black-box test changed after performing the first black-box test, and the degree of success of the first black-box test.

Abstract: Testing computer software applications by performing a first black-box test on a computer software application, identifying any instructions of the computer software application that were reached by a payload of the first black-box test, determining a degree of success of the first black-box test in accordance with predefined success criteria, determining whether any of the instructions that were reached by the payload changed after performing the first black-box test, deciding whether to perform a second black-box test on the computer software application, where the deciding whether to perform the second black-box test is based on whether any of the instructions that were reached by the payload of the first black-box test changed after performing the first black-box test, and the degree of success of the first black-box test.

Abstract: A system and method for constructing a user callstack trace in a computer to monitor a user defined Function of a user program in relation to one or more predetermined events is provided. The system and method provides generating a user callstack trace for display to the user from data in memory in relation to a predetermined event of interest to the user. The user callstack trace communicates information corresponding to the execution of the Function for the predetermined event independent of the plurality of outlined functions. The plurality of outlined functions are artificially generated in response to compiling the user program having the Function.

Abstract: Disclosed herein is a system and method for optimizing a developer's ability to find and navigate relevant documents, relationships, and other information related to an identifier in the code they are developing. An inline viewport is presented to the user in response to the user selecting an identifier in the code whereby the user is able to see relevant information related to the identifier in a spatially consistent location with the code they are investigating. Further, the developer has the ability to make changes to the code in the viewport without leaving the current editor.

Abstract: A method, system and computer program product for ensuring a user interface specification accurately describes its corresponding user interface. The system links sections of the user interface code with corresponding user interface objects. Furthermore, the system links these sections of the user interface code with corresponding sections of the user interface specification. Upon detecting a modification to the user interface code which reflects an update to the user interface, the system notifies the user that the user interface specification needs to be updated. By linking the user interface objects to the user interface code and linking the user interface code to the corresponding sections of the user interface specification, appropriate modifications to the user interface specification can be recommended or implemented based on the modifications to the corresponding sections of the user interface code, which reflect the changes to the corresponding objects on the user interface.

Abstract: Embodiments relate to a computer implemented process, system and program product for identification of a root method for a thread. In one aspect of the embodiment the process includes instrumenting code to form instrumented code and creating stack sample data. It also includes creating method stack sample data in a case that the stack sample data exceeds a stack sample data threshold. It also includes, determining whether a root method is identified, the determining based on using the method stack sample data; and reporting any root method identified for a respective thread.

Abstract: Probes are instrumented in multiple software modules of a computer system having virtual machines running therein and executed in a coordinated manner. An output of one probe may be used to conditionally trigger another probe so that the precision of collected data may be improved. In addition, outputs of probes that are triggered in different software modules by related events may be synchronized and analyzed collectively. Probes also may be parallel processed in different processors so that multiple probes can be processed concurrently.

Abstract: A method is used in handling managed object data. A software object is created which represents a managed object in a data storage system. The software object holds performance data for the managed object. The software object is created in response to a request for the performance data. Based on a determination that the performance data held by the software object is out of date, the software object is destroyed.

Abstract: Embodiments provide methods for managing data generated by software transactions, such as event tracing software. In one embodiment, data generated by event tracing software is monitored. The throughput of the data generated may then be modulated based on various criteria, such as a target data rate. The throughput target may be specified on a per-system basis or individual basis. Based on the throughput, the level of detail recorded is modulated. Individual processes may determine a limit or quota depending on their contribution to the throughput. In one embodiment, the method calls for a trace are modified with different property specifications to meet a desired throughput of event tracing data.

Abstract: A system and method for performing integrated testing of a virtual space are disclosed. For performing the integrated testing, test inputs simulating virtual space actions by users may be obtained for one or more test cases. Responsive to such test inputs being obtained, one or more test commands may be generated for testing virtual space functionalities implemented on client computing platforms and for testing server components being executed on one or more virtual space servers to facilitate user participation of the virtual space. The generated test commands may be executed and test results may be obtained. The obtained test results may be compared with expected results corresponding to the test cases for verification.

Abstract: Aspects of the disclosure provide a method for profiling. The method includes collecting symbol information to map traces of codes in a program to memory addresses storing corresponding native codes that are dynamically compiled from the traces of codes during an execution of the program, and making the symbol information available after the dynamic compilation to analyze profiling data sampled during the execution of the program.

Abstract: A system and a method for providing a core dump-level stack trace. In one example, the method includes receiving, by a processing device, a recorded state of a program, the recorded state including a base address of the program and a stack frame including an executable address for a call instruction of a function of the program; determining, by the processing device, a list of functions in view of the recorded state of the program, and creating, by the processing device, a stack trace in view of the list of functions without using debugging symbols.

Abstract: Systems and methods of debugging client applications may provide for detecting a runtime error in a first version of a client application, and obtaining a second version of the client application server in response to the runtime error. The second version of the client application may be used to conduct a diagnosis of the runtime error.

Abstract: A model checking system is described herein that more effectively verifies and validates the design of distributed applications by providing a model and a generic framework to check application invariant properties, detect anomaly behaviors, and monitor application health. The model checking system checks on-line application behavior against application models derived from formal descriptions of the application. The system formulates the concrete application as an abstract model and a number of rules or properties that are expected to hold for the application under all conditions. The model checker compares the actual application execution with the models and either confirms that the properties hold true or reports that the properties are violated. Thus, the model checking system provides more efficient and thorough validation of distributed applications under more realistic production conditions.

Abstract: An advanced communication controller unit for a distributed communication system having a plurality of communication controller units, at least one being an advanced communication controller unit, each coupled to a communication medium and adapted to communicate using a communication is presented. The advanced communication controller unit comprises a protocol event recording circuit having a monitoring input connected to at least one protocol event data transmission path of the advanced communication controller unit and a debug output connected to a memory device; and adapted to filter protocol event data received from the monitoring input depending on at least one configuration parameter and to provide filtered protocol event data to the debug output. A method for recording protocol events using a protocol event recording circuit in an advanced communication controller unit and a vehicle comprising at least one advanced communication controller unit are also disclosed.

Abstract: In one embodiment, a method includes maintaining thread analysis metadata for a multi-threaded application. The metadata may include a thread vector clock for threads of the application and a synchronization vector clock for synchronization objects of the application. In addition, an initialization log and an access log can be generated and maintained for memory accesses occurring during execution of the application. From this metadata, it may be determined if an access to a memory element by a thread is a potential invalid access for a different scheduling of the application. Other embodiments are described and claimed.

Abstract: Systems, methods, and computer program products for data synchronization across multiple devices using mail and push notification services is disclosed.

Abstract: Technologies are provided in embodiments for receiving an enclave program for operation in an enclave, identifying at least one shared object dependency of the enclave program, determining whether the shared object dependency corresponds to at least one enclave shared object, causing association between the shared object dependency and the enclave shared object in circumstances where the shared object dependency corresponds to the enclave shared object, and causing association between the shared object dependency and an enclave-loadable non-enclave shared object in circumstances where the shared object dependency fails to correspond to the enclave shared object.

Abstract: Determining instruction execution history in a debugger, including: retrieving, from an instruction cache, cache data that includes an age value for each cache line in the instruction cache; sorting, by the age value for each cache line, entries in the instruction cache; retrieving, using an address contained in each cache line, one or more instructions associated with the address contained in each cache line; and displaying the one or more instructions.

Abstract: View definitions are created for deterministic performance analysis in real-time computing systems, and can then be used to present views for analyzing outliers that occur during run-time execution. Trace data created by a real-time application is compared to a set of view definitions to determine whether the trace data matches the view definition. If so, then related records from the trace are gathered according to specifications in the matched view definition, and calculations (such as elapsed time) can then be performed using the related records. A view definition may be created by prompting a user for selection of parameters to be programmatically inserted into a markup language document. A capability may be provided whereby a user can receive additional information (which is extracted from the trace data, according to specifications in the matched view definition) upon a user gesture such as hovering a selection means over a displayed view.

Abstract: Graphical programming or modeling environments in which a coding standard can be applied to graphical programs or models are disclosed. The present invention provides mechanisms for applying the coding standard to graphical programs/models in the graphical programming/modeling environments. The mechanisms may detect violations of the coding standard in the graphical model and report such violations to the users. The mechanisms may automatically correct the graphical model to remove the violations from the graphical model. The mechanisms may also automatically avoid the violations in the simulation and/or code generation of the graphical model.

Abstract: A trace-data processing device comprises an input to receive source-specific trace data streams comprising trace messages carrying execution-flow information on a program execution flow performed by a source device under test or under observation, hereinafter DUT. A trace-data processing unit (526, 1100) derives from the trace data stream runtime information associated with the program execution flow performed by the DUT. The trace-data processing unit comprises a message-distribution stage (1104), a plurality of parallel message-processing stages (1106.1, . . . 1106.N), and a result consolidation stage (1108) connected with the message-processing stages. The message-distribution stage (1104) distributes the received trace data stream (T1?) over the message-processing stages in the form of respective trace data sequences. The message-processing stages (1106.1, . . . 1106.N) generate from the trace data sections runtime information sequences.

Abstract: Techniques for minifying a client-side web application are described. In one embodiment, a computer-implemented method includes performing a static analysis of a set of files written in a dynamic programming language that make up the web application. A single minified web application file is generated based on a traversal of a dependency graph that includes, in proper dependency order, components that are needed at runtime and does not include components of the set of files that will not be needed at runtime. The single minified web application file may be delivered to end user computing devices in place of the original set of files without loss of web application functionality.

Abstract: Described are a system and method for identifying variables which impact performance of software under development. Data is collected that is related to performance characteristics of the software under development. Performance change gradients are determined between previous builds of the software under development. A set of performance change factors are generated from the collected data that corresponds to each performance change gradient. Performance characteristic data corresponding to a current build of the software under development are compared to the performance change gradients. At least one fault component from the set of performance change factors that influences performance of the current build is output in response to the comparison between the performance characteristic data corresponding to the current build and the plurality of performance change gradients.

Abstract: A software testing tool providing dynamic testing stubs. The tool comprises, comprising a processor, a non-transitory memory coupled to the processor, and an application stored in the memory. When executed by the processor in a single execution session, the application receives a definition of a test stub as a mapping from a stub handle to a reply message content, stores the test stub in a data store as an entry comprising the stub handle and the reply content, receives an invocation of an application programming interface, where the invocation comprises an argument, searches the data store for a test stub having a stub handle that matches at least in part to the argument received in the invocation of the application programming interface, and transmits a reply message defined by the test stub.

Abstract: A system, method, and techniques for dynamically probing a method are provided. An example method includes identifying a target method to probe in an application. The method also includes modifying the target method to include a call to a helper method that passes a rulename to a native method in a shared object library. The native method includes a marker associated with a probe point inserted in the application at a location relative to the target method, and the rulename identifies the marker associated with the probe point. The method further includes during execution of the application on a computing device, detecting when the target method is invoked. The method also includes when the method is invoked, passing the rulename to the native method in the shared object library.

Abstract: Devices and methods are provided for acquiring abnormal information. For example, a test command line is generated using one or more data processors based on at least information associated with test demand information; the generated test command line is run using the data processors to send a test instruction to execute a test of a condition associated with the demand information; a test log is monitored using the data processors; keyword identification is performed using the data processors on the test log; and in response to one or more test abnormal keywords existing in the test log based on at least information associated with the keyword identification, abnormal information associated with the abnormal keywords is extracted using the data processors from the test log.

Abstract: Methods and apparatus, including computer program products, for mobile application development and deployment. A method includes, in a server residing in a network, receiving an application description file from a design system communicatively linked to the server, the application description file capable of targeting multiple application platforms and representing a workflow of an application for user equipment communicatively linked to the server, generating from the received application description file an application envelope comprising at least a subset of the application description file, and sending the application envelope to a client application residing in the user equipment, the client application interpreting contents of the application envelope.

Abstract: A method to create an aspect oriented, color coding algorithm for a graphical user interface, wherein a graphical user interface (“GUI”) is generated when a code base is executed, and wherein the GUI comprises a plurality of interactable graphical objects, wherein the method compiles the code base, identifies in the compiled code base a first object join point, wherein the compiled code base at the first object join point creates and displays a first interactable graphical object, and determines a first address in the code base for the first object join point. The method further creates a mapping table, writes the first interactable graphical object and the first address to that mapping table, and encodes the mapping table in an aspect oriented, color coding algorithm written to a computer readable medium.

Abstract: A method for precisely counting guest branch instructions in a virtualized computer system is described. In one embodiment, guest instructions execute in a direct execution mode of the virtualized computer system. The direct execution mode operates at a first privilege level having a lower privilege than a second privilege level. A branch count of previously executed first privilege level branch instructions is maintained as instructions execute. Execution of a first privilege level branch instruction caused by a control transfer to the direct execution mode is detected. Responsive to the detection, a guest branch instruction count is determined based on the first privilege level branch count.

Abstract: A tracing system may divide trace objectives across multiple instances of an application, then deploy the objectives to be traced. The results of the various objectives may be aggregated into a detailed tracing representation of the application. The trace objectives may define specific functions, processes, memory objects, events, input parameters, or other subsets of tracing data that may be collected. The objectives may be deployed on separate instances of an application that may be running on different devices. In some cases, the objectives may be deployed at different time intervals. The trace objectives may be lightweight, relatively non-intrusive tracing workloads that, when results are aggregated, may provide a holistic view of an application's performance.

Abstract: A tracing system may use an evaluation mechanism to determine which functions to include or exclude during tracing. The architecture may evaluate functions when functions or groups of functions may be loaded for execution, as well as each time a function may be encountered. The evaluation mechanism may use whitelists, blacklists, and various expressions to identify which functions to trace and which functions to exclude. The evaluation mechanism may evaluate an expression that may identify specific conditions under which a function may be traced or not traced. The tracing mechanism may create wrapping functions for each function, including callback functions.

Abstract: A technique for detecting patterns in the execution of an application. The technique identifies a sequence of methods which are invoked and obtains information regarding attributes of the methods. For example, attribute information such as a class hierarchy can be obtained from an instrumentation API. A data structure representing a hierarchy of the attributes can be created and compared to one or more reference data structures which describe patterns of interest. A decision can be made to provide instrumentation for the methods having the matching attributes. The decision can consider how frequently the pattern is detected and overhead costs of the instrumentation.

Abstract: The present invention discloses a XSS detection method for detecting the XSS vulnerabilities in a web page, comprising for each parameter-value pair in a set of parameter-value pairs that can be accepted by the web page: constructing a parameter-value pair in which a dedicated script is inserted; assembling a URL corresponding to the web page based on the parameter-value pair in which a dedicated script is inserted; acquiring the dynamic web page content corresponding to the assembled URL; and simulating the execution of the acquired dynamic web page content, if the dedicated script is executed, it is determined that the processing of the parameter in the web page contains XSS vulnerabilities. The present invention further discloses a corresponding XSS detection device and a web site security scanning system and a web scanning system using such a device.

Abstract: A tracing and debugging system may collect both performance related tracer data and snapshot data. The tracer data may contain aggregated performance and operational data, while the snapshot data may contain call stack, source code, and other information that may be useful for debugging and detailed understanding of an application. The snapshot data may be stored in a separate database from the tracer data, as the snapshot data may contain data that may be private or sensitive, while the tracer data may be aggregated information that may be less sensitive. A debugging user interface may be used to access, display, and browse the stored snapshot data.

Abstract: The present subject matter is directed to systems and methods for automating the testing of multi-function systems, such as naming registration systems and the like. A method of testing a registry, and the like, may include providing a command phrase including an add command and at least one function that includes an artificial attribute for a domain added by the add command. The command phrase may specify an operation, a protocol, and an object. The operation may include at least one of add, delete, or update domain. The protocol may include at least one of RRP and EPP. One or more parameters associated with the command phrase may be provided and may include an expected response code and/or a variable. One or more additional parameters that are associated with the command phrase may be determined and a database may be accessed to provide the one or more additional parameters.

Abstract: Debugging of code of a computer program is facilitated by having a plurality of internal breakpoints associated with lines of code previously set by a processor, during a debugging session, while implementing one or more step-type operations. During execution of another operation, internal breakpoints are disabled as encountered and deemed unnecessary to completion of the another operation. A count of a number of interrupts of one or more interrupt-types experienced during execution of the another operation is maintained, and responsive to the count exceeding a threshold, the disabling is varied to remove at least N internal breakpoints responsive to encountering an internal breakpoint during execution of the another operation deemed unnecessary to completion of the another operation, where N?2.

Abstract: A system and method of debugging application software operating on a system-on-chip processor (SOC) with a system trace macrocell.