Abstract: A mechanism for debugging a transformation document is disclosed, wherein a debugging mechanism interacts with a user interface to enable a user to specify one or more breakpoints. The user may specify a breakpoint at a particular location in the transformation document or a source document. In addition, the user may specify one or more breakpoints using an expression, or based upon XSL messages. In addition to interacting with the user interface, the debugging mechanism also interacts with a transformation processor, which is the mechanism that actually processes the source and transformation documents to derive a result document. Before and after each processing action, the transformation processor sends a pre-action and a post-action message, respectively, to the debugging mechanism. The debugging mechanism uses the information in these messages to determine whether a breakpoint has been reached.

Abstract: A mechanism for determining restrictions to impose on an implementation of a service is disclosed. When an application desires an implementation for a particular service, the application makes a request to a framework. The framework receives the request and, in response, determines what restrictions, if any, need to be imposed on the requested implementation. The restrictions are determined by determining whether any permissions have been granted to the application requesting the implementation, and if so, processing the permissions to derive a set of zero or more restrictions to impose on the implementation. The permissions are processed such that the set of restrictions is least restrictive. Once the restrictions are determined, the framework dynamically constructs the requested implementation. The requested implementation is constructed such that it incorporates a general implementation of the service, the restrictions, and enforcement logic for enforcing the restrictions on the general implementation.

Abstract: A general purpose application interaction protocol, referred to herein as the Commerce Exchange Interaction Protocol (CXIP), governs the exchange of data between applications resident in computers in a distributed network such as the Internet, providing for application interoperability. CXIP enables process communications among network-distributed software applications, particularly, but not exclusively, among software applications having dissimilar platforms, language dependencies or vendor dependencies. Data structures, object and method invocation requests are exchanged between applications by means of XML documents based on CXIP semantics. The application interaction protocol, which is not specific to any particular functional domain and specifies interactions that are independent of transactional content, includes four component parts: message formats, message types, exchange semantics and transportation assumptions.

Abstract: A JAVA application is typically executed as follows. First, a thread from a thread pool is attached to the JAVA virtual machine (JVM). Then, that thread is used to execute the JAVA application. Once the execution of the JAVA application is completed, the thread is detached from the JVM and returned to the thread pool. This is repeated for every execution of a JAVA application. Because this constant attaching and detaching of threads imposes additional overhead on the system, this process is inefficient. To improve the efficiency of the execution process, a “sticky attach” mechanism is provided. With sticky attach, a thread is not attached and detached from the JVM each time a JAVA application is executed. Rather, a thread is attached to the JVM only once: the first time it is used to execute a JAVA application. When execution of the JAVA application is completed, the thread is returned to the thread pool without detaching from the JVM.

Abstract: A line driver provides an output signal onto an output. The line driver includes a first current driver coupled to a first terminal of the output. The first current driver is capable of providing a first current to the first terminal that is sufficient to cause an output voltage having a magnitude Y to appear across the output. The first current driver includes a first plurality of elements to provide the first current to the first terminal of the output, each of the plurality of elements having a maximum voltage tolerance that is less than the magnitude Y.

Abstract: A mechanism is disclosed for constructing dispatch tables which enable transitive method override. A dispatch table for a class C (wherein C is within a package P and is a subclass of superclass S) is constructed as follows. First, the S dispatch table is copied and is used as the starting point for the C dispatch table. Then, for each locally declared method m in C, the method m is checked to determine whether it has been marked public/protected. If so, then the S dispatch table is checked for a public/protected entry corresponding to a method having the same name as method m. If such an entry is found, then the corresponding entry in the C dispatch table is overridden. Otherwise, a new entry is allocated in the C dispatch table and is marked public/protected. In addition, the S dispatch table is checked for a package private (private to package P) entry corresponding to a method having the same name as method m.

Abstract: A mechanism for merging multiple source policies to derive a resultant policy is disclosed. The source policies, which may represent sets of laws/regulations, and which may comprise zero or more entries with each entry comprising an identifier and a set of one or more limitations, are merged by first selecting a current entry in a first source policy. Then a determination is made as to whether there is an entry in a second source policy which corresponds to the current entry. If so, then the limitations in the current entry are processed with the limitations in the corresponding entry to derive a set of resultant limitations. The limitations are processed such that the resultant limitations comprise the most restrictive limitations of the current entry and the corresponding entry. By doing so, it is ensured that the resultant limitations comply with both the first and the second source policies.

Abstract: A mechanism for enabling customized session managers to interact with a network server is disclosed. The mechanism includes a programming interface which enables customized session managers to “plug in” to and to interact with the server. This programming interface makes it possible to change session management functionality without having to make any changes to the core server. It also makes it possible to incorporate multiple session managers into the server. These aspects of the programming interface significantly increase the flexibility and scalability of the web server. In addition to the programming interface, the mechanism further includes a service engine for coordinating the interaction with the session managers. For each client request, the service engine determines which application needs to be invoked. Then, based upon that application, the service engine determines which, if any, associated session manager needs to be invoked to manager session (i.e.

Abstract: A method lookup mechanism is disclosed which not only enforces accessibility constraints imposed by modularity constructs but also enables transitive method override. According to one embodiment, when a method m is invoked on a target object, the method m in a resolved class is checked to determine whether it has been declared as public/protected. If so, then standard method lookup may be used to determine the proper implementation of method m to invoke. However, if the resolved method is not declared as public/protected, then the class of the target object is searched for an implementation of the method m. If no implementation is found, then a superclass of the target object class is searched for an implementation. This process repeats until an implementation is found or until the resolved class is reached.

Abstract: A method lookup mechanism is disclosed which not only enforces accessibility constraints imposed by modularity constructs but also enables transitive method override. According to one embodiment, when a method m is invoked on a target object, the resolved method m in a resolved class is checked to determine whether it has been declared as public/protected. If so, then standard method lookup may be used to determine the proper implementation of method m to invoke. However, if the resolved method is not declared as public/protected, then a path stack is constructed. The path stack provides a listing of the class hierarchy between the target object and the resolved class. Once constructed, the path stack is used to determine which implementation of method m to invoke in response to the method invocation. Specifically, the resolved method m is initially set as the candidate method to invoke. Then a downward search is performed through the classes on the path stack.

Abstract: The present invention requires a computing device to interact with an authorized host computer on a fairly regular basis in order to maintain operability. In one embodiment, there is stored within the computing device an authorization parameter. This parameter is checked upon the occurrence of certain events to determine whether it has expired. If the authorization parameter has expired, then the present invention renders the computing device inoperable. The only way to update this parameter, and hence to maintain operability, is for the computing device to interact with an authorized host computer. Unless a thief knows which host computer to contact, and how to properly interact with that host computer (both of which are unlikely), the authorization parameter of a stolen device will not be updated. As a result, the stolen device will become inoperable within a relatively short time after the theft.

Abstract: A mechanism for replicating and maintaining files in a space-efficient manner is disclosed. In one embodiment, a current file is replicated by associating the data blocks of the current file with both the current file and a new file. The new file and the current files are separate and distinct from each other. Data blocks remain shared until the content of one file is modified. Only the data blocks affected by the modification are duplicated. The two files share the unchanged data blocks, but both files are each associated with additional data blocks that reflect the modification. Reference values are used to track how many files are associated with each data block. In another embodiment, a file descriptor is linked to a filename at the request of a user or application. The present invention avoids needless duplication of the same data blocks among copies of a file.

Abstract: An improved mechanism for processing client requests is disclosed. The first time a client request for a particular resource is received by a server, it is processed by stepping through a configuration file, and selectively executing directives specified in the configuration file. As the request is processed, a list of executed directives is compiled. This list of directives is stored for future reference. The next time a request for that same resource is received, the configuration file is not consulted. Instead, the stored list of directives is accessed and used to process the request. More specifically, all of the directives on the list are executed to process the request. Processing the subsequent request in this way eliminates much of the overhead associated with request processing. There is no need to open or to step through the configuration file, and there is no need to step through the directives themselves.

Abstract: An improved transmitter capable of achieving high linearity with minimal power dissipation is disclosed, comprising a digital phase splitter and an output stage. The digital phase splitter includes a positive phase digital-to-analog converter (DAC) for converting the positive phase portion of a set of input digital data into an analog signal, and a negative phase DAC for converting the negative phase portion of the set of input digital data into another analog signal. The analog signals from the phase splitter are passed to the output stage for transmission onto a transmission medium. The transmitter may be operated in low power dissipation mode. Because the phases of the input digital signal are split in the digital domain prior to the output stage, the output stage experiences minimal crossover distortion. Consequently, the transmitter is able to minimize power dissipation without suffering from poor linearity performance.

Abstract: Executing a thread unaware or non-thread-safe application in a multi-threaded environment is potentially hazardous. If multiple instances of the thread unaware application are executed concurrently in the same process space, as may be the case in a multi-threaded environment, one instance may try to modify or overwrite the information used by the other instance, which can lead to serious errors. To enable a thread unaware application to be executed safely in a multi-threaded environment, multiple thread pools are implemented. That is, for each thread-unaware or non-thread-safe application, a separate thread pool is defined and associated with the application. Unlike other thread pools, though, this thread pool has its maximum number of threads parameter set to “1”. By limiting the number of threads in the pool to 1, it is guaranteed that there will be no more than one instance of the thread unaware application executing at any one time.

Abstract: An intuitive scrolling feedback mechanism is provided to enable novice and infrequent computer users to understand and to utilize the scrolling functionality offered by a computing device. Scrolling feedback is provided by displaying a portion of a set of information in a display area. In addition, a control region is displayed, comprising one or more activable controls. These controls, when activated by a user via a user interface, cause a different portion of the set of information to be displayed in the display area. In addition, a status region is displayed, comprising a plurality of location indicators. A subset of the location indicators is displayed in a first manner (e.g. a darker color), while the remainder of the location indicators is displayed in a second and different manner (e.g. a lighter color). The subset of the indicators is determined based upon the portion of the set of information that is currently being displayed in the display region.

Abstract: An improved mechanism for managing an object cache is disclosed. An object cache manager receives a request for an object resident in an object cache. A determination is made as to whether the requested object is currently within a particular portion of the object cache. If the requested object is within this particular portion, then the object cache manager keeps the requested object within this portion of the cache by maintaining the requested object at its current position relative to other objects in the object cache. By removing the overhead of repositioning objects within a particular portion of the object cache, the efficiency of object cache management is significantly improved.

Abstract: An improved mechanism for efficiently polling file descriptors in a large scale computer system is disclosed. The polling of the file descriptors is performed by first determining, based upon a set of indication information, which file descriptors are eligible for polling. A file descriptor is eligible for polling if the indication information for that file descriptor indicates that the file associated with that file descriptor might (but does not necessarily) have an event pending. Only if a file descriptor is determined to be eligible will the file descriptor and the file associated with the file descriptor be polled. By polling only the eligible file descriptors in a system, the overhead associated with the polling operation is kept to a minimum. As a result, even in a large scale system with a large number of file descriptors, polling is still performed efficiently.

Abstract: A mechanism is disclosed for implementing multiple thread pools in a computer system to optimize system performance. In accordance with the invention, a plurality of thread pools is initially allocated within a process space, with each thread pool comprising one or more threads. Each thread pool has a set of characteristics associated therewith, and the characteristics of each thread pool are customized for one or more particular types of service. After the thread pools have been allocated, the system receives one or more requests. When a request is received, it is processed to determine with which thread pool the request is to be associated. This processing is carried out by determining the type of service being requested by the request, and then determining which thread pool is associated with that type of service. Alternatively, this processing is carried out by extracting a set of indication information (e.g.

Abstract: Apparatus for processing memory access requests includes first and second state machines for controlling access to first and second memory banks and an arbiter. While the first state machine is processing a current memory access request for the first memory bank, the arbiter recieves a next memory access and determines wheather the next memory access request will interfere with the processing of the current memory access request. If no interference will occur, and if the next access request is directed to the second memory bank, the second state machine begins processing he next memory access request before completion of processing of the current memory access request. The second state machine begins processing of the next memory access request during a mandatory wait period implemented by the first state machine. The first and second state machines process the current and next memory access request concurrently.