Abstract:
A method and an apparatus to execute a code with value profiling are described. The code may include an access to an untyped variable. During the execution, runtime values of the untyped variable may be randomly inspected. A value profile may be established to predict one or more expected types of future runtime values for the untyped variable. The code may be recompiled according to the value profile to optimize the access of the untyped variable for the future runtime values.
Abstract:
A device generates code with a technical computing environment (TCE) based on a model and information associated with a target processor, registers an algorithm with the TCE, automatically sets optimization parameters applied during generation of the code based on the algorithm, executes the generated code, receives feedback based on execution of the generated code, and uses the feedback to automatically update the optimization parameters and to automatically regenerate the code with the TCE until an optimal code is achieved for the target processor.
Abstract:
A memory scanning system may scan memory objects to determine usage frequency by scanning each memory object using a mapping of the processes stored in memory. The scanning may be performed multiple times to generate a usage history for each page or unit of memory. In some cases, scanning may be performed at different frequencies to determine multiple classifications of usage. The mapping may create a detailed topology of memory usage, including multiple classifications of access frequency, as well as several other classifications. Based on the topology, the objects in memory may be copied to another storage medium or optimized for performance or power consumption.
Abstract:
A processor-implemented method and/or computer program product negotiates the processing of incoming transactions based on resource utilization status of backend systems in an appliance cluster. An incoming transaction, which is a specialized function for an appliance, is received by a processor. The processor determines whether the incoming transaction can be processed by the appliance cluster based on a current threshold level and a current transaction count, and then identifies a target appliance from the appliance cluster as a negotiation device in response to determining that the incoming transaction cannot be processed.
Abstract:
Attempts to update confirmation information or firmware for a hardware device can be monitored using a secure counter that is configured to monotonically adjust a current value of the secure counter for each update or update attempt. The value of the counter can be determined every time the validity of the firmware is confirmed, and this value can be stored to a secure location. At subsequent times, such as during a boot process, the actual value of the counter can be determined and compared with the expected value. If the values do not match, such that the firmware may be in an unexpected state, an action can be taken, such as to prevent access to, or isolate, the hardware until such time as the firmware can be validated or updated to an expected state.
Abstract:
An approach to determine a power-on-hour offset for a memory device that is newly-installed into a computer system is provided, which subtracts a current power-on-hour count of the memory device from a current power-on-hour value of a power supply that supplies operative power to the memory device within the computer system. In response to the computer system powering down, an accumulated power-on-hour for the memory device is determined by subtracting the power-on-hour offset of the memory from a current power-on-hour value of the computer system power supply. The determined power-on-hour offset and accumulated power-on-hour values are saved into one or more designated bytes of a free area of electrically erasable programmable read-only memory of the memory device that are available for data storage by a memory controller, and wherein data stored therein persists after operative power is lost to the memory device, the memory controller or the computer system.
Abstract:
At least some of the illustrative embodiments are a computer-readable medium storing a program that, when executed by a processor, causes the processor to obtain values indicative of a state of an operating context parameter during execution of a traced program on a target processor, and display an indication of a proportion of time during a trace period of the traced program that the target processor operated with the operating context parameter in a particular state.
Abstract:
An on-chip function call aware software code profiling counter system and method is disclosed. When building software code a compiler/tool-chain can modify prologues and epilogues of functions to add instrumentation code which uniquely identifies the function. Each function included in the instrumented source code tree is assigned a unique identifier (ID) by the compiler/tool-chain. Writing a unique ID for a function to a register starts profiling for the function. The profiling is performed by a counter that counts the number of instruction cycles since the last unique ID was written to the register. When a unique ID for a next function to be profiled is written to the register, the old register value and the counter value are latched to one or more buffers and the counter is cleared to start the next count sequence for the next function to be profiled.
Abstract:
A method includes receiving event information corresponding to an event associated with the operation of a system. The method also includes identifying related event information corresponding to a plurality of events that occurred before the event, wherein the event is related to the plurality of events. The method also includes storing the event information and the related event information as a group of events. The method further includes determining whether the group of events occurred within a first specified amount of time by identifying a time window ending at the occurrence of the event and beginning the first specified amount of time before the occurrence of the event and determining whether each event of the group of events occurred during the identified time window. The method further includes identifying an incident associated with the group of events upon determining that the group of events occurred within the first specified amount of time.
Abstract:
A method of calculating performance parameters for a type of data being executed by a unified processing subunit. In one embodiment, a task (e.g., a draw call) is executed by a processing pipeline (e.g., a GPU). An ALU within a unified processing subunit (e.g., a unified shader processing unit) is queried to determine a type of data (e.g., vertex processing, pixel shading) being processed by the ALU. Performance parameters (e.g., bottleneck and utilization) for the type of data being processed by the ALU is calculated and displayed (e.g., stacked graph). Accordingly, software developers can visualize component workloads of a unified processing subunit architecture. As a result, utilization of the unified processing subunit processing a particular data may be maximized while bottleneck is reduced. Therefore, the efficiency of the unified processing subunit and the processing pipeline is improved.