Abstract: A method, system, architecture and apparatus for generating a shared library for a pervasive device target platform which can accommodate relocatable data. A tool chain in furtherance of this purpose can be arranged in accordance with the present invention to include a compiler programmed to compile source code into a compiled object and a linker programmed to link the compiled object into a linked object using a relocatable data segment. In this regard, in a preferred aspect of the invention a linker configuration file can be included for use in the linker which specifies the use of the relocatable data segment in lieu of a position independent data segment. The tool chain further can be arranged to include a relocation data extraction tool programmed to extract relocation data from the linked object and to dispose the relocation data in a relocation data file configured for disposition in a pervasive device.

Abstract: Methods of optimizing the loading of a previously linked file into working memory in a computer for executing in a memory sharable with other executables, and converting an image which has been previously linked for executing in an unshared memory into an image optimized for use with virtual memory.

Abstract: A method of administration in a JMX environment of software systems to be administered, represented by first respective MBeans, and at least one administration application, in which the administration acts produce the exposure of MBeans in at least one MBeanServer server, characterized in that it is implemented by means of a mediation device and that it comprises the following steps: a tree structure of administration components representing first MBeans, in which each component is identified by a unique name, is constructed following the receipt of the name of an administration component, the mediation device dispatches a determined command to the administration component thus identified which, if it represents an MBean, exposes in the MBeanServer this Mbean; when the administration component possesses descendent administration components in the hierarchical structure, the mediation device propagates the command to the descendents.

Abstract: An apparatus, system, and method are disclosed for communicating binary data using a self-descriptive binary data structure. The binary data structure also may be referred to as a microcode reconstruct and boot (MRB) image. The binary data structure includes a plurality of data segments, a target data set, and a data structure descriptor. Each of the data segments has a data segment header and data field. The target data set is stored within the data field and may be an executable. The data structure descriptor is descriptive of the binary data structure and identifies the location of the target data set within the data field. The binary data structure is self-descriptive in that the location of an individual target data set may be identified by the data structure descriptor.

Abstract: The present disclosure is a method for storing possible classes or class containers (Jars) based on usage patterns of JVMs. The classes may be stored in the memory area of the JVM that may use those most and is closest to the actual system for access. Distributed environments where memory is shared across all systems can access memory across all systems but access speed is only high close to the current system with a fast connection and bandwidth towards this memory area.

Abstract: A method, system, architecture and apparatus for generating a shared library for a pervasive device target platform which can accommodate relocatable data. A tool chain in furtherance of this purpose can be arranged in accordance with the present invention to include a compiler programmed to compile source code into a compiled object and a linker programmed to link the compiled object into a linked object using a relocatable data segment. In this regard, in a preferred aspect of the invention a linker configuration file can be included for use in the linker which specifies the use of the relocatable data segment in lieu of a position independent data segment. The tool chain further can be arranged to include a relocation data extraction tool programmed to extract relocation data from the linked object and to dispose the relocation data in a relocation data file configured for disposition in a pervasive device.

Abstract: A system and method for generating run-time images of a software program, such as an operating system, builds a run-time image from a plurality of selected software program components, each of which is a discrete packet of functionality. Each component not only specifies its properties and resources but also provides script for its own build behavior. To build the run-time image, a configuration is constructed to include instances of selected components, and the scripts of the instances are invoked such that each component instance builds itself into the run-time image. A general framework is provided for managing the components and the build process. A prototyping scheme is provided for a component to inherit its properties, resources, and script from other components. Each component may also specify dependency data in terms of component inclusion in the run-time image and the orders in which the components are built into the run-time image.

Abstract: A small footprint device, such as a smart card, can securely run multiple programs from unrelated vendors by the inclusion of a context barrier isolating the execution of the programs. The context barrier performs security checks to see that principal and object are within the same namespace or memory space and to see that a requested action is appropriate for an object to be operated upon.

Abstract: Dynamic management proxies provide type-safe, intuitive, and flexible interfaces to management entities. In an embodiment, a strongly-typed user interface is defined for each management entity. The dynamic proxy receives user requests via this user interface. The dynamic proxies converts user requests into generic requests in compliance with the management entities generic interface. The generic requests are communicated to the management entity via the generic interface. Dynamic management proxies are created at runtime. This allows the management interface to be seamlessly extended.

Abstract: Provided is a method, system, program, and computer readable medium for maintaining a database of objects. At least one structured document is received representing an instance of an object including attributes and attribute values defined for a class. Content of the structured document representing the object is added into the database, wherein the database is capable of storing multiple structured documents representing multiple objects. In another implementation, an instance of at least one object including attributes and attribute values defined for a class is generated. For each generated object, a structured document is generated representing the object and including a representation of the attributes and attribute values in the object. Each structured document is transferred to the database to maintain.

Abstract: Systems and methods are described herein for determining which components of a source operating system are required to be included in a target operating system to support selected source operating system features in the target operating system. Data objects are constructed to represent each component and feature of the source operating system, each data object identifying Exports and References for the component or feature it represents. The dependency model identifies, for each component, other components that must be included in a target operating system having the component. A target operating system builder program receives input from a user as to the features the user desires to include in the target operating system. The dependency model is utilized to identify and select the components from the source operating system necessary to support the selected features. The selected components are then linked to create the target operating system.

Abstract: The present invention is generally directed to a method, system, and article of manufacture that ensures the integrity of programs having variable portions. One aspect of this invention is a method for protecting software products having variant portions. This method includes identifying a reference to an external target in a software product, creating an identifier for the external target, and adding the identifier to the reference. In some embodiments, the unique identifier is a digital signature and the reference to an external target is a call to an external library.

Abstract: A system, method, and computer program product for communicating with an LDAP server. When an LDAP server call is required, the call is encapsulated in a wrapper class which then interacts with the LDAP server.

Abstract: A method for conditionally sharing dynamically compiled code between different class loaders is provided. In this method, bytecodes of a first class type are compiled into a compiled code if the bytecodes have not been compiled. The locations of sequence of instructions in the compiled code that are loader dependent are then recorded. Thereafter, the loader dependencies in the compiled code are compared to determine whether the compiled code can be used by a method of a second class type. If the loader dependencies of the second class type are different from the loader dependencies of the first class type, the compiled code for the method of the first class type is cloned. Subsequently, portions of the cloned code that are loader dependent are modified to enable the method of the second class type to use the cloned code.

Abstract: A program which is linked or bound by reference (referenced program) into one or more other programs supports multiple valid export signatures, each corresponding to a respective version of the referenced program. When a program is built, it records the current signature of each referenced program it is bound to. When subsequently determining whether to rebuild the program, the previously recorded signature of any referenced program is compared with all currently supported signatures of the referenced program, and only if none of the supported signatures matches does the program need to be re-built to ensure compatibility with the referenced program. Preferably, the referenced program is a program library containing supporting procedures, intended to be used by multiple applications programs which are bound to it.

Abstract: An infrastructure that allows applications to run with specified versions of dependent assemblies, wherein each assembly may exist and run side-by-side on the system with other versions of the same assembly being used by other applications. An application provides a manifest to specify any desired assembly versions on which it is dependent. Similarly, each assembly may have an assembly manifest that specifies the versions of assemblies on which it is dependent. During an initialization phase, an activation context is created for the application, based on the manifests, to map version independent names to a particular assembly version maintained on the system. While the application is in a running phase, for any globally named object that the application wants created, the activation context is accessed to locate the application's or assembly's manifest-specified version. The manifests and activation context constructed therefrom thus isolate an application from assembly version changes.

Abstract: A method of linking a plurality of object code modules to form an executable program, each object code module having section data, a set of relocation instructions and one or more symbols, each symbol having a plurality of attributes associated therewith, wherein the relocation instructions include a data retrieval instruction having a symbol field identifying a symbol and an attribute field identifying a symbol attribute associated with the identified symbol to be retrieved, the method including reading at least one relocation instruction from the set of relocation instructions and where the relocation instruction is a data retrieval instruction, determining the symbol identified by the symbol field and retrieving one of the plurality of symbol attributes associated with the symbol in dependence on the contents of the symbol attributes field of the instruction.

Abstract: In an ASP server farm, requests to use an application are directed to a particular executing instance of the application (or an appropriate component thereof) that is identified as being the least loaded of the available such instances of the application or its component. The number of such instances is dynamically increased or decreased in response to the number of requests for the application or components thereof. Requests may be directed (in accordance with the first aspect) or the instances adjusted (in accordance with a second aspect) on a per client-basis, in which instances of the application and/or components thereof are reserved for the use of a user or a particular group of users. Operation in this manner facilitates compliance with service agreements with respective users or groups of users.

Abstract: A first software program is capable of being referenced by a second software program. For compiling the second program, information, including an interface definition, is generated by a converter for the first program. Also, a generator is provided for generating first source code from the interface definition, so that second source code may be developed and the second program may be compiled from the first and second source code.

Abstract: A system for utilizing an object library to dynamically match the type structures of a client and a server to determine compatibility. Once compatibility has been established, the client and server can communicate through a secure connection. Information can be sent asynchronously between the client and the server, and a flow control provides a buffer at the flow origin to ensure that there is no overflow of information to the recipient of the flow.

Abstract: A system and method of sharing a resource includes receiving a request for a shared resource in a locking repository. The request is from a requestor and the requestor is one of several applications. Each of the applications is running on one of several Java virtual machines (JVMs). The shared resource is locked to the requester, if the shared resource is identified as available in the master locking repository.

Abstract: A system implementing an embedded software application having at least one data type includes a first memory that stores a constant part of the at least one data type (class), a second memory that stores a variable part of the at least one data type (class), and a linking object that actively links the first memory and the second memory such that the constant part and the variable part are aggregated into the at least one data type (class). A method for implementing an embedded software application includes storing the constant part in a first memory, storing the variable part in a second memory, defining a linking object between the constant part and the variable part, and implementing the embedded software application by implementing the constant part, which is stored in the first memory, and implementing the at least one variable part, which stored in the second memory, by implementing the linking object.

Abstract: A mutability mechanism is provided for parsing an object at loading time. The mutability mechanism inserts a property into the object that indicates whether or not the object is immutable. The mutability mechanism looks at the code for the object and determines whether any other objects can modify the object. If the object cannot be modified after it is created, then the new property is set to indicate that the object is immutable; otherwise, the property is set to indicate that the object is mutable. This property can be inspected at runtime when a call is made to a program object. If an object passed as an argument is marked mutable, a clone of this object must be passed to the callee. However, if an object passed as an argument is marked immutable, a simple reference to the object may be passed as an argument to the callee.

Abstract: In a cluster of computing nodes having shared access to one or more volumes of data storage using a parallel file system, a method for managing the data storage includes selecting a first one of the nodes to serve as a session manager node, and selecting a second one of the nodes to serve as a session node for a data management application. A session of the data management application is created on the session node by sending a message from the session node to the session manager node, causing the session manager node to distribute information regarding the session among the nodes in the cluster. Responsive to the information distributed by the session manager node, events are received at the session node from the nodes in the cluster for processing by the data management application.

Abstract: Store for operating system resource data is provided integrally with application program resource data in an application program environment to create a shared object. Application programs executing the in application program environment are prevented from accessing the operating system resource data portion of the shared object.

Abstract: A method, system and infrastructure that allow an application to run with specified versions of assemblies bound thereto, while allowing the application author, assembly publisher and/or an administrator to change the originally-specified version as desired. Each assembly may exist and run side-by-side on the system with other versions of the same assembly being used by other applications. An application manifest specifies any desired assembly versions, which may be redirected to another version (overridden) by an application configuration. A publisher configuration provided by an assembly publisher can similarly override the specified version. Lastly, an administrator configuration is capable of overriding other configuration versioning information. A table built from the manifest and any configuration redirection may be accessed during execution to quickly locate the appropriate version.

Abstract: A compiler has a detection unit, a conversion unit, and a expansion unit. The detection unit detects a predetermined target from an input source program. The conversion unit converts the target detected by the detection unit into a procedure call. The expansion unit generates an online code describing a definition of a procedure to be called by the procedure call obtained by the detection unit. The compiler outputs a program in which the target detected by the detection unit is replaced with a procedure call, and an online code corresponding to the procedure call.

Abstract: Method and apparatus for switching between multiple implementations of a routine. A plurality of implementations of a routine are compiled into respective object code modules. In one embodiment, each implementation of the routine is adapted for a particular hardware configuration. The different object code modules are associated with respective sets of hardware characteristics and with the name of the routine. When the application program and library are loaded into memory of the computer system, a references to the routine are resolved using the sets of hardware characteristics and the hardware configuration of the system.

Abstract: In one embodiment a method for handling shadow or overlay memories is described wherein a linker contains a description of the memory of a target embedded system so that each memory space is described for each state of the control devices. The linker in one embodiment contains the shadow memory configuration information so that post linker tools such as loaders and debuggers can utilize this information. The information for each configuration includes how to get the device into the state that makes each configuration visible in address space, how to get the device back into the state it was in before the state was changed and how to find out the state the device is in.

Abstract: Methods and apparatus for dynamic runtime partitioning of network-based client/server applications using a Model-View-Controller pattern are provided. Such dynamic partitioning is accomplished by requiring that the application specify: (i) that access to the Model be done through an application programming interface (API) which allows the system runtime to dynamically allocate and access Model storage on the client and/or server; and (ii) that access to the View be done through an API which allows the system runtime to dynamically allocate and access View components on the client and/or server. This enables applications written and tested in such a manner (referred to herein as the “canonical form”) to execute in a non-distributed mode or in a dynamically partitioned mode in which client/server issues are not a factor. This greatly facilitates development of the application.

Abstract: Method and apparatus for optimization of an executable program that calls procedures in a shared library. Code segments that read procedure address information from a linkage table are first identified. Each linkage code segment is associated with a call to a procedure in the shared library, and the address information in the linkage table is associated with the procedures in the shared library. During program execution, the address information is read from the linkage table and substitute code segments are generated for the linkage code segments. Each substitute code segment has direct loads of the address information for calling the associated procedure instead of the original references to the linkage table. Thereafter, the substitute code segments are executed instead of the linkage code segments.

Abstract: A system and method for providing dynamic class reloading using a modular, pluggable and maintainable class loader is described. Each application in an application server (or alternatively in any implementation) may include a dynamic class loader module. The class loader module may include a hierarchical stack of class loaders. Each module in the application may be associated with its own class loader. Each class loader may be responsible for loading one or more classes. When a class is changed, the changed class may be detected by the class loader module. Any notification for a class change may come to the class loader controller so that the concerned class loader can be replaced. The class loaders for all classes that depend on the changed class may also be replaced. The replaced class loaders may then reload the affected classes.

Abstract: A method and system for representing and implementing a concept between two functional domains (e.g., programming languages) by using a proxy component in a first domain to wrap a component of a second domain, where the proxy component has a semantic usability in the first domain closely corresponding to the semantic usability of the underlying component from the second domain. Further, provided is a method and system for automatically generating such a proxy component. Such proxy components may be used to gradually transform a digital entity (e.g., a software application) from a first digital domain to a second digital domain. Further, such proxy components may be generated using models that transform a component of a first domain to a component (e.g., a proxy component) of a second domain.

Abstract: The present invention provides a visual linker. The visual linker includes a link server that implements linking instructions for sections to a memory. The visual linker also includes a graphical user interface that receives said instructions and displays said sections within said memory. The visual linker also includes an application programming interface that receives said instructions and reports the results of said linking instruction and said sections within said memory. The visual linker also includes an incomplete link comprising sections not allocated to said memory. The visual linker also includes a link recipe comprising said instructions implemented by said link server.

Abstract: One embodiment of the present invention provides a system that uses a shared library to facilitate sharing objects containing metadata. During operation, the system receives identifiers for a set of objects to be included in the shared library. Next, the system generates a shared library containing the set of objects. In doing so, the system configures a symbol table within the shared library to include an identifier for each object. The system then installs the shared library in a file system, and configures the file system so that the shared library file can be accessed through a set of symbolic names, wherein each object is associated with a different symbolic name. This allows each object in the shared library to be referenced through its own symbolic name. Note that the present invention uses the shared library mechanism in a manner which differs from its typical use (sharing compiled, executable code).

Abstract: A library manager holds related program fragments, for example, control logic fragments and visualization program fragments sharing the same control variables, in library files. Multiple copies of control logic program fragments are instantiated to develop a control program and of the control variable tags for each copy of the control logic program fragments are renamed to prevent conflicts. At a later time, visualization program fragments related to the control logic program fragments are identified by their common origin in the library manger. The control variables of these visual program fragments may then be automatically renamed by using their library files as a guide. The library files may also hold related non-program information.

Abstract: A method and apparatus for managing a run-time environment is provided for improving performance and scalability of networked computer systems. In one example of the invention, a method starts by loading a class file, the class file specifying a class that includes a static class variable and a static initializer to initialize the static class variable. The static initializer is then invoked to initialize the static class variable. The class and the initialized static class variable are then saved in a second class file. The second class file is then loaded into a shared memory, the second class file including the class and the initialized static class variable.

Abstract: An interpreter serves for a programming language. It first receives information specifying names and the like of multiple applications written in the programming language. Then, the interpreter generates individual application areas corresponding to the applications for storing data required for execution of the applications. It also generates a task for each of the applications and executes the application in the task. If the interpreter detects a new class in required classes during execution of the individual applications, it loads bytecodes for the new class in a shared area. Also, if the new class has a class variable, the interpreter allocates a class variable area for the class variable which corresponds to the application. Furthermore, to access a class variable during execution of an application, the interpreter accesses a class variable area for the class variable in the individual application area corresponding to the application.

Abstract: An integrated circuit card includes a storage device to store one or more code files and one or more data files, and control logic. The control logic implements an ICC runtime environment that executes an applet in response to a command identifying both a code file and a data file received from a host system.

Abstract: A customization framework includes a design component configured to receive a customization input, from a customizable subsystem, indicative of a customization. A runtime component receives a request from the customizable subsystem and identifies and customizes a portion of the customizable subsystem based on the request.

Abstract: An application package device with which a user can perform test customization without causing other users inconvenience before actual customization. First, a customization defining section stores customization information in either an individual customization information database or a shared customization information database. At the time of customization, a customization performing section searches the individual customization information database for customization information under the keywords of a user name and an object name such as an image name and a form name. When succeeding in the searching, the customization performing section performs the customization processes on the basis of the retrieved customization information. On the other hand, when failing in the searching, the customization performing section searches the shared customization information database for the customization information under the keyword of the object name.

Abstract: A first software program may be read in by way of a compiler, which is included in a computer, and is converted into a second software program that may be executed by the computer. This second software program may be executed on the computer so that a control function of a stored-program controller can be taken over by a computer by way of a particular process.

Abstract: A method and system for non-intrusively modifying an executable file E comprising references (F1, F2 and F3) with functions disposed in at least one shared library B within a computer. At least two new files are created, a META file comprising several unresolved references in executable file E and a services file comprising new functions or services to be inserted in executable file E. The link editing phase assigns the unresolved references to the META file as a priority and subsequently to shared library B. When the references are listed in the META file, a link is then established for the reference between executable file E and the META file in the place of shared library B. The META file may then assign one or more functions stored in service file S and/or in shared library B to the reference.

Abstract: A garbage collector maintains a block-offset table. That table contains locator information including an entry for each of a plurality of “cards” into which the collector treats at least a portion of heap memory as divided. Certain of the code values that an entry can assume specify the location of the object or free block in which the card begins. Other codes indicate that such information can be obtained from a table entry some number of table entries ahead of the entry that assumes that value. The possible offset values in the encoding populate only very sparsely the range between the highest and lowest values represented by the possible code values. By thus leaving large gaps in the range of possible offsets encoded, a collector can achieve an advantageous compromise between the expense of finding a block location and the expense of updating the block-offset table.

Abstract: The present invention discloses a technique for sharing data between at least two operating systems. In accordance with the present invention, a volume is provided in a data storage device. The provided volume is a portion of memory within the data storage device. The provided volume is accessible by a source operating system residing on a source computer and a target operating system residing on a target computer. Data is generated within the provided volume using the source operating system. The generated data is in a format that is readable by the target operating system.

Abstract: A system and method are described for providing automated incremental compilation of computer programs. The system has a library generation logic that generates a dynamic link library of a plurality of computer programs, and a work area creation logic that creates a program work area. A program copy logic copies at least one computer program into the program work area to enable the computer program to be modified. A program generation logic then generates an executable program that includes all of the computer programs in said program work area and the plurality of computer programs in the dynamic link library.

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 data processing system and method for managing the storage of compiled instructions used in interpretive programming language applications is implemented. As the applications are implemented in an interpreted programming language, the instructions are compiled into byte-codes to be used by a virtual machine and are subsequently stored in a memory. The data processing system and method recognize that a same application may be used repeatedly and periodically. Thus, the data processing system and method diminish the time required to compile the instructions of an interpretive programming language application, while preserving the compilation of interpretive programming code across sessions accessing the code. Additionally, the data processing system and method diminish the time required to download a Java application and, therefore, allow a user to more efficiently access Internet operations.

Abstract: The present invention relates to a mechanism for copying selected routines from shared libraries into application programs thereby generating optimized application programs for more rapid execution of the various applications within a computer system. Since optimized programs occupy space on disk and in RAM, programs are preferably selected for optimization based on their frequency of execution and the frequency with which calls are made to the shared libraries. Profile information may be used to identify the execution efficiency of the various application programs and thereby identify the best candidates for optimization. Further, profile information may be employed to copy individual routines contained within the libraries rather than having to copy an entire library where only one routine within the library was of interest.

Abstract: A method and mechanism for executing an application by a processor in a multi-processor configuration of processors, each having an associated instruction memory is presented. The application receives object code that includes an image for at least one other processor in the multi-processor configuration of processors. The application binds an import variable in the image to a parameter value and stores the image for the at least one other processor into the associated instruction memory.