Abstract: In general, techniques for secure communicating over a virtual IPMB of a mainframe computing system are described herein. More specifically, the mainframe computing system comprises a plurality of independent computing cells communicatively coupled together by a network interconnect and that form a plurality of partitions. Each partition is a logical association of one or more of the cells to define a single execution environment. Each cell further executes a virtual intelligent platform management interface (IPMI) protocol to define and configure a respective logical intelligent platform management bus (IPMB) for each of the partitions. Each of the IPMBs logically interconnects with each of the other cells included within the same partition, and each is defined for communication of IMPI messages over the network interconnect. The cells securely communicate the IPMI messages between each of the one or more other cells of each partition via the respective logical IPMB of each partition.

Abstract: In general, techniques for communicating within a mainframe computing system via a virtual Intelligent Platform Management Interface (IPMI) protocol are described herein. More specifically, the mainframe computing system comprises a first cell that forms an Ethernet message to directly encapsulate an IPMI message without further encapsulating the IPMI message within any other protocol message. The mainframe computing system further comprises other cells. The cell further transmits the Ethernet message to at least one of the other cells. The first cell couples to the other cells via an Ethernet interconnect however, and not an IPMB. The cells overcome this limitation by communicating via the virtual IPMI protocol, which allows each cell to leverage pre-configured support of IPMI over the Ethernet interconnect and thereby forgo the requirement of an IPMB to communicate via IPMI.

Abstract: In general, techniques for secure communicating over a virtual IPMB of a mainframe computing system are described herein. More specifically, the mainframe computing system comprises a plurality of independent computing cells communicatively coupled together by a network interconnect and that form a plurality of partitions. Each partition is a logical association of one or more of the cells to define a single execution environment. Each cell further executes a virtual intelligent platform management interface (IPMI) protocol to define and configure a respective logical intelligent platform management bus (IPMB) for each of the partitions. Each of the IPMBs logically interconnects with each of the other cells included within the same partition, and each is defined for communication of IMPI messages over the network interconnect. The cells securely communicate the IPMI messages between each of the one or more other cells of each partition via the respective logical IPMB of each partition.

Abstract: In general, techniques for performing decentralized hardware partitioning within a multiprocessing computing system are described herein. More specifically, the multiprocessing computing system comprises first and second independent computing cells, where the first cell comprises a first processor that calculates a partition identifier. The partition identifier uniquely identifies a partition to which the first cell belongs. The first cell also comprises a second processor that establishes the partition within the multiprocessing computing system based on the partition identifier, and executes a single operating system across the partition. In the event the established partition successfully includes the first and second cells, the first and second cells execute the single operating system across the partition. Because the cells themselves perform the partitioning process, scalability may be achieved more easily.

Abstract: Method and apparatus for exposing an application object model to web-based clients. The various embodiments involve parsing each HTTP-form-processing request received from a client by a web server. As the property names are obtained form the HTTP-form-processing request, the objects in the object model are traversed. When the end of the HTTP-form-processing request is reached and the object model is traversed, a selected property of a referenced object is returned to the client.

Abstract: A method and apparatus for operating a server system. In one embodiment a server-control element is coupled to the server system and is configured to provide access to management functions for managing the server system. The server-control element generates event reports in response to status data received from the server system, each event report containing status data indicative of an operational characteristic of the server system. A bridge is coupled to the server-control element and is configured to register with the server-control element to receive events reports. The bridge stores data from the event reports. Command requests received from a bridge-type client by the bridge are submitted to the server-control element, the commands specified by the command requests for invoking the management functions. The bridge provides the stored data from event reports to the bridge-type client in response to requests for the stored data.

Abstract: A method for implementing a hierarchy of component object model interfaces. A hierarchy of component object model interfaces is defined in which an interface at a lowest level of the hierarchy inherits from an interface at the highest level of the hierarchy. A class is defined that includes a first template class that is associated with the highest level of the hierarchy. A second template class inherits from the first template class and is associated with the lowest level of the hierarchy. The second template class is instantiated with an interface as a template parameter. Thus, the instantiation of an object of the most specialized class provides the base interface from which the most generalized class derives.

Abstract: Software and methods for extending preexisting objects to support persistence. One use of the present invention is to extend component object model (COM) objects to support persistence in a simple, predefined system. COM objects may be saved to persistence storage and loaded from persistence storage using user-provided save and load methods. When objects are constructed, the objects are added to a Persistent Object Registry. Objects preferably utilize smart pointers, rather than simple pointers, in order to enable restoration of the pointer values after a save and load cycle. The smart pointers include an object ID along with the address. The object ID, together with the information stored in the Persistent Object Registry, may be used to restore a pointer value after loading. Objects may be saved by streaming the objects out and loaded by streaming the objects back into memory from a file.

Abstract: Method and apparatus for implementing persistent data in object-oriented programs. A class declaration is separated into two parts, a first structure type for storage of one or more data values, and a class that derives from the structure type. Objects of the structure type are instantiated and initialized in the source program. The class definition includes a static method that converts an object of the structure type to an instance of the class in response to a reference to the method. Thereby, memory for the objects is allocated and data values are assigned to the objects at compile-time.

Abstract: A method and apparatus for reusing a thread for different programmed operations are provided in various embodiments. In one embodiment, different application operations are defined as subclasses of a thread operation class, and a thread is implemented with a thread class. In one embodiment, the application operations can be queued to the thread for scheduled execution using the thread. In another embodiment, a first application operation can start a thread and be executed therewith, while a second application operation can attach to the thread for execution.

Abstract: Methods for converting from a COM interface pointer to an underlying C++ object are described in various embodiments. In the various embodiments, classes are constructed in support of the underlying C++ object. The classes are used to enforce rules safely convert a COM interface pointer. One rule is that a COM interface to be converted cannot be marshaled. A second rule is that an object requesting the C++ object must have legal access to the COM interface (for example, the same execution unit). A third rule is that the object type of the COM interface must be in the inheritance hierarchy of the C++ object.

Abstract: A system and method for managing a pool of threads for executing thread operations. A thread pool is instantiated which includes a plurality of threads, and a work queue having program controllable states is instantiated. Thread operations are queued to the work queue when the work queue is in a running or suspended state, and when the work queue is in a stopped state requests to queue thread operations are denied. The work queue supports controlled allocation of thread resources to a variety of thread operations.

Abstract: Apparatus for sealing and protecting the spliced junction of butt-spliced cables including a protective sleeve and two toroidal sealing rings and the method of assembling the sleeve and rings to the spliced cable which results in the sleeve being centered over the splice and the sealing rings spaced substantially midway between the splice and the ends of the protective sleeve.

Abstract: A self-attaching receptacle box adapted for use with light fixtures to afford a quick connection for the light fixture wiring to a source of current comprises a rectangular housing having in one wall thereof an opening for receiving the wires and a projection adjacent one edge of the opening, and a slotted opening in said wall opposite the projection through which extends a clamp portion of a block. The block has a threaded opening to receive a screw extending from an adjacent wall member which permits the block to be moved toward and away from the wire-receiving opening to clamp the projection and clamp portion of the block against opposite edges of a standard knock-out opening of the light fixture or other supporting panel.