Abstract: A method and that display certain aspects of a computer memory on a display screen in accordance with a fractal curve. In at least one embodiment, the fractal curve is a Hilbert curve. The fractal curve display can be used as an aid in visualizing various types of information about a computer memory. Certain embodiments have a display that remains static, while other embodiments have a display that is dynamic and changes in real-time to reflect changes in memory.

Abstract: Techniques for establishing a pre-scheduled international telephone call using a callback service to take advantage of the arbitrage which exists when there is a rate difference between calls originating in the source and destination countries. In one approach the customer sends the call information to the callback service by completing an Internet based form. The callback service automatically places calls as pre-scheduled dates and times arrive. In one implementation, the callback service automatically sends reminder E-mail messages to call participants at some pre-determined time before the call is to occur. Another extension would allow call participants to respond to the reminder E-mail with information permitting their call to be forwarded or cancelled.

Abstract: A system for converting between parallel data and serial data is described. In the system, individual bits of the parallel data are latched into individual registers. Each register is coupled to a corresponding AND gate which is also connected to receive phased clock signals. The output terminals of the AND gates are connected to an OR gate. Using the system, with appropriately phased clocks, the parallel data is converted into serial data.

Abstract: Data structures, methods and devices for reducing computing overhead by utilizing threads which are effective to listen for requests for new connections, for new requests for services, and process requests for services in a distributed client/server-based object oriented operating system are disclosed. In one aspect of the invention, a method of processing a request for service from a client, involves listening for a request using a first server side thread which is effective to listen for and process requests on a connection, reading the header of the request using the first server side thread, and processing the request. In another aspect of the invention, a client writes a request for service on a connection between the client and a server using a first client side thread which is effective for dispatching requests and listening for replies to the request, and determines whether a reply from the server is expected in response to the request for service.

Abstract: An access control database defines access rights through the use of access control objects. The access control objects include group objects, each defining a group and a set of users who are members of the group, and rule objects. A first subset of the rule objects each specify a set of the group objects, a set of the management objects, and access rights by the users who are members of the groups defined by the specified set of the group objects to the specified set of management objects. The access control server responds to the access requests from the users by granting, denying and partially granting and denying the access requested in each access request in accordance with the access rights specified in the access control database. A database management system receives management information from the network and stores that information in a set of database tables.

Abstract: An improved method and system for generating packets for transmission over different routes on a network is presented. In a large network such as the Internet, each route over the network carries different size packets which are not compatible unless they are fragmented into smaller segments. Initially, the technique determines a maximum transmission unit (MTU) capable of being transmitted over a predetermined route. Next, the size of each packet to be transmitted over the network is compared with the MTU size. If the comparison indicates the packet is larger than the MTU, the packet must be processed further before it can be transmitted over the route. The additional processing initially divides the total number of transmission units contained within the packet by the MTU value. The integer result of this division is temporarily stored in a DCOUNT variable and the remainder of the division in a RCOUNT variable. If the remainder in RCOUNT is non-zero, the value in DCOUNT is incremented by one.

Abstract: Methods and apparatus for the efficient allocation of shared memory in a multi-threaded computer system are disclosed. In accordance with one embodiment of the present invention, a computer-implemented method for allocating memory shared by multiple threads in a multi-threaded computing system includes partitioning the shared memory into a plurality of blocks, and grouping the multiple threads into at least a first group and a second group. A selected block is allocated to a selected thread which may attempt to allocate an object in the selected block. The allocation of the selected block to the selected thread is based at least partially upon whether the selected thread is a part of the first group or the second group. In one embodiment, grouping the multiple threads into the first group and the second group includes identifying a particular thread and determining whether the particular thread is a fast allocating thread.

Abstract: An improved method and apparatus for providing a service framework for a distributed object network system are provided. In some embodiments, an apparatus that includes a server, a service for a limited resource residing on the server, and a pool of workers for the service that execute service requests from a client in a distributed object network system is provided. In some embodiments, a method that includes providing client-side service request encapsulation, balancing workloads among clones of service locators, clones of services, and workers in a worker pool of a service, and improving fault tolerance in a distributed object network system is provided.

Abstract: Methods, software, and apparatus for analyzing a software component within an application builder tool are disclosed. The present invention relates, in one aspect, to a method for analyzing a software component that can be visually moved within an application builder tool running on a computer. The method involves obtaining the software component to be analyzed and determining if the software component has an associated information class. When it is determined that the software component has an associated information class, the information class is queried about information stored within the information class, otherwise automatic analysis using design patterns is applied to analyze the class. In one embodiment, the information stored within the information class relates to methods, properties, and/or events.

Abstract: A system and method for adding support for new contained classes to a container class that does not require the container class to be recompiled. Also disclosed is a system and method for building container classes that does not require a programmer to explicitly code methods related to the contained classes. A set of classes, called Supporters, provides support for contained classes. Related Supporters can be packaged as a library that can be shipped with programming environments, updated APIs or device drivers. A SupporterAffinity manages Supporters for use by a particular contained class. A SupporterAffinity method (“getSupporter”) can be invoked to add a Supporter for a new contained class to the SupporterAffinity, allowing an instance of the container class to use that Supporter's methods on instances of the new contained class. Because support for the new container class is provided via the SupporterAffinity and the new Supporter, there is no need to recode the container class.

Abstract: A system dynamically constructs a graphical user interface associated with an application. A command class library stores command classes that represent additional functions to be integrated with the application. An execution unit attempts to instantiate the command classes at run-time of the application, determines which of the command classes were instantiated successfully, and constructs the graphical user interface for the application such that the graphical user interface contains the additional functions of the successfully instantiated command classes.

Abstract: The present invention provides an efficient streamlined pipeline for a counterflow pipeline processor with a renaming table. The counterflow pipeline includes an execution pipe having multiple instruction stages forming an instruction pipe, a plurality of result stages forming a result pipe, and a corresponding plurality of comparator/inserters. Each comparator/inserter couples an instruction stage to a corresponding result stages. The counterflow pipeline also includes a register exam stage with the renaming table. The renaming table has entries for associating each register value of an instruction with a unique renamed register number (RRN), thereby eliminating the need for arbitration and housekeeping (killing of stale register values), as instructions and their respective register values counterflow in the streamlined counterflow pipeline. An RRN counter, such as a modulo counter, is coupled to the renaming table and provides unique RRNs for assignment to new register values.

Abstract: A processor including a large register file utilizes a dirty bit storage coupled to the register file and a dirty bit logic that controls resetting of the dirty bit storage. The dirty bit logic determines whether a register or group of registers in the register file has been written since the process was loaded or the context was last restored and, if written generates a value in the dirty bit storage that designates the written condition of the register or group of registers. When the context is next saved, the dirty bit logic saves a particular register or group of registers when the dirty bit storage indicates that a register or group of registers was written. If the register or group of registers was not written, the context is switched without saving the register or group of registers. The dirty bit storage is initialized when a process is loaded or the context changes.

Abstract: Floating point numbers and other values are represented in a “delimited” representation in which all numbers, including those which would in the IEEE Std. 754 representation, be in the de-normalized format, are in a format which is normalized with an implicit most significant digit having the value “one.” For numbers which would, in the IEEE Std. 754 representation, be in the de-normalized format, in the delimited representation.

Abstract: Methods and apparatuses for deferring, or delaying, the throwing of exceptions are disclosed. In one aspect of the present invention, an exception is raised during an invocation of a first object within an object-based system. The exception may be processed by catching the exception and making a first copy of the exception. Making the first copy of the exception includes storing the first copy of the exception in a dynamic memory. The first copy of the exception may then be processed by creating a runtime copy of the exception that is stored on an execution heap. The runtime copy of the exception may is then caught. The first copy of the exception is deleted from the dynamic memory, and the caught runtime copy of the exception is reprocessed. In one embodiment, processing the first copy of the exception includes throwing the first copy of the exception as a system exception.

Abstract: To establish an access-controlled communications path between a client and an access-controlled network resource, a determination is initially made as to whether the client is authorized to access the access-controlled resource. If the client is authorized to access the access-controlled resource, then a validated parameter associated with the client (e.g. the client's network address) is established. Thereafter, a firewall is configured to selectively accept future communications having the validated parameter associated therewith. Upon receiving a communication, a determination is made as to whether the communication has the validated parameter associated therewith. If it does (thereby indicating that the communication is from the authorized client), then the communication is allowed to pass through the firewall to the access-controlled network resource. In this manner, an access-controlled communications path is established between the client and the access-controlled network resource.

Abstract: A computer-implemented method for allocating memory resources to a device driver is described. In one embodiment, a device driver generates a request for memory allocation in terms of an abstract memory address space. This abstract memory address space is also used by a bus manager to manage the allocation of memory. The driver forwards the request to the bus manager which can then allocate memory or translate the request to a second abstract memory address space used by a second bus manager. When the request is passed to a platform manager, real memory is allocated and the requested memory is passed back to the driver. Thus, by making a memory request in terms of a bus manager's abstract memory address space, the necessity of coding the driver to request real addresses (a platform-specific operation) is avoided.

Abstract: The present invention relates to a method and circuit for prefetching direct memory access descriptors from memory of a computer system, and storing the prefetched direct memory access descriptors within a unified descriptor memory for subsequent access by direct memory access controllers. The descriptors are generated by a central processing unit of the computer system while executing software applications. The descriptors define data transfer operations between memory of the computer system and input/output devices via direct memory access controllers. The direct memory access controllers generate requests for descriptors. Upon generation of a request, the unified descriptor memory is checked to determine whether the requested descriptor is contained therein. If the requested descriptor is contained within the unified descriptor memory, the request descriptor is provided to the requesting direct memory access controller.

Abstract: Methods, apparatus, and software for endianness checking for platform-independent device drivers is described. According to one embodiment, the method of the invention includes generating a memory allocation request from a platform-independent device driver. The driver instantiates a memory constraints object that is configured to report the endianness of the driver. The request is received by a bus manger that is configured to process memory allocation requests from the device driver and has an endianness independent of the device driver. If the endianness of the bus manager and device driver is inconsistent, then the memory constraints object is transformed to be consistent with the bus manager's endianness.