Abstract: A vacuum exhaust system includes a plurality of turbo pumps that evacuate a plurality of vacuum chambers. A plurality of chamber valves are positioned between the turbo pumps and the plurality of vacuum chambers. A plurality of branch channels are each connected to a corresponding exhaust of the plurality of turbo pumps and a main channel is formed from a confluence of the branch channels. A booster vacuum pump is connected to the main channel. A backing vacuum pump is connected to an exhaust of the booster vacuum pump. A plurality of bypass channels, each having a valve, provide a fluid communication path between at least some of the plurality of vacuum chambers and the booster vacuum pump.

Abstract: The present disclosure provides a method of suppressing oomycete infection, such as a Phytophthora infection, or triggering programmed cell death in Solanaceae plants comprising administering at least one modulator, wherein the at least one modulator modulates at least one of the genes listed in Table 1 or variants or homologs thereof. The present disclosure also provides compositions useful in suppressing oomycete infection, such as Phytophthora infection and triggering programmed cell death and screening assays for identifying substances useful in suppressing oomycete infection, such as Phytophthora infection and triggering programmed cell death.

Abstract: A method, apparatus, system, and signal-bearing medium that, in an embodiment, receive an allocation request for a resource and registers the resource as a non-voting participant if the resource desires to delegate commit voting to another resource. The registered resource is then prohibited from participating in an enclosing transactional context and instead is informed when the transaction completes. The resource is enlisted as a voting participant if the resource does not desire to delegate commit voting. In this way, when multiple resources are used in a transaction, a resource may be registered and receive notifications of transaction completion instead of being enlisted and voting on commit decisions. The result of a transaction in which a single resource takes responsibility for a number of other resources is that transaction completion avoids the two-phase commit protocol and the resulting performance degradation.

Abstract: Method, apparatus, computer program, and computer program product for managing the durability of a plurality of transactions, each transaction including a plurality of operations, each operation for applying to a data item, each operation having a reliability level associated therewith. Each transaction is divided into one or more sub-transactions based upon reliability level of the operations. Sub-transactions are then dispatched to a persistence manager for execution against a persistent store.

Abstract: A a user is enabled to specify policy information for use by a persistence manager in determining how to persist information relating to a data item so as achieve a desired level of reliability. The user is permitted to specify at least two behavior requirements to be associated with information to be persisted. The first behavior requirement is specifiable for a first system state, and the second behavior state is specifiable for a second system state. The behavior requirements are interpretable by the persistence manager to determine a persistence behavior necessary to conform with the policy information.

Abstract: Method, apparatus, and computer program product for reducing the number of operations performed by a persistence manager against a persistent store of data items. A plurality of requests from an application are received. Each request is mapped into a transaction for performance against the persistent store, each transaction having at least one operation. Transactions are accumulated and preprocessed to reduce the number of operations for performance against the persistent store.

Abstract: A method and apparatus for performing distributed object calls uses proxies and memory allocation and deallocation. Specifically, an object reference to an object is obtained. The object reference is used to create a proxy handle data structure that will represent the object. The proxy handle is passed to a client application stub function which calls the object. The stub function is also passed input and output parameters along with exception information. An object request broker finds an appropriate implementation in a server application. The server application allocates memory for implementing the call. The object is implemented and the memory allocated by the server application is deallocated. The server application responds to the client, whereupon the client makes another object call using the same proxy handle or destroys the proxy handle. Multiple initialization of object calls is avoided because the object call can be initialized just once for a particular object.

Abstract: A building component comprises a cladding unit having an overhang portion and a securing portion. The outer face of the overhang portion serves as a barge/fascia board. The lower face of the overhang portion serves as a soffit. The cladding unit is thin walled and of sideways S-shape with three spaced upright parallel walls. Two walls namely one outer wall and the center wall are connected by a lower plate at their lower edges and form the overhang and two walls namely the center wall and the second outer wall are connected by an upper plate at their upper edges and form the securing portion.

Abstract: The present invention is a method and apparatus for processing an object call between a client computer system and a server computer system. Using the method of the present invention, an object call begins on the client system with the construction of a parameterized vector. The parameterized vector has one entry for each parameter of the object call. The parameterized vector is then initialized so that each entry in the parameterized vector points to one of the parameters of the object call. The entries within the parameterized vector are arranged in a canonical order. Once the parameterized vector has been completed, the object call is transmitted from the client to the server. The server receives the object call and allocates a parameter area. The parameter area has one entry for each parameter of the object call. The parameter area is then initialized so that each entry within the parameter area contains an object pointed to by one of the entries in the parameterized vector.

Abstract: A method for making distributed object calls from client applications to server applications is disclosed. In particular, the method of the present invention involves generating a data structure that contains information about the available IDL-defined interfaces and their related operations. An application loaded in the client computer then packs a request containing information about a specific operation of an interface into a message buffer in the client computer according to a predetermined format specified in the request. The message buffer is then sent to a server computer that unpacks the request from the message buffer based upon the predetermined format. The server processes the request and responds by packing its response into a message buffer according to a predetermined format. The message buffer is then transported to the client computer that unpacks the response from the message buffer.

Abstract: A method for defining Interface Definition Language-defined data types, operations, or interfaces is defined. In particular, an ASCII string descriptor is generated that identifies the data type, interface, or operation. Characters are used to identify the base types of any data types, while a combination of characters and numerals are used to identify compound types and characteristics of those compound types. For operations, characters and numerals are used to identify the number and types of parameters, number of exceptions, and number of contexts contained in the operation. Interfaces are described using a numeral that indicates the number of operations included in the interfaces. By converting the original IDL description to an ASCII string, generic functions can be created to transport object calls across heterogeneous systems.

Abstract: A method and apparatus for asynchronously calling and implementing objects is disclosed. Object calls to perform an operation are performed asynchronously by calling the appropriate stub function from the client application and passing in the object reference, input parameters, and a pointer to a completion routine. The object reference, input parameters, and completion routine address are provided to a client-side execution environment. The client-side execution environment stores the completion routine address and transmits the input parameters to a server-side execution environment. The server-side execution environment calls a method in the server application that implements the requested operation. The server application performs the requested operation. Once the call has been responded to, the client-side execution environment calls the completion routine and passes it the output parameters to the requested operation.

Abstract: An object-oriented method and apparatus for delivering information from one component to another across a network of computers includes the steps of loading implementation libraries for adapter and information provider components into memory and creating factory objects for those components. When a request arrives over the network, the factory objects are called and stream objects are created by the factory objects. Data is then streamed from an information provider source to the original requester using the stream objects.

Abstract: A data structure representing an Interface Definition Language ("IDL") source file is disclosed. The data structure is preferably produced during the compilation of the source file and generation of language-specific source code. The data structure includes a variable-sized array of data structures representing entries from the source file in addition to an array of strings containing each line in the source file. Each of the entry data structures contains a fixed part containing information about the name and attributes of the source file entry and a variable part that depends upon the entry's data type. The data structure can be stored in a file or database for run-time access by distributed applications.

Abstract: A method and apparatus for transporting IDL-defined data structures to and from a format convenient for transport between two computers are disclosed. The data structures is originally described in a string. The string description is converted to a different format containing additional information about the alignment and size of the data structure. An application in the sending computer removes the alignment from the data structure and stores the data structure in a buffer. The data structure is stored in the output buffer in a predetermined format that is based upon the type of the data structure. The buffer is then transmitted to a data file or to the memory of the receiving computer. The receiving computer extracts the data structure from the buffer based upon the predetermined format. The data structure is realigned and stored in the memory of the second computer.