2212 results about "Serialization" patented technology

A system in the form of a software solution that provides new and unique solutions to the need to secure digital environments. The present invention uses innovative and new forms of multi-factor user authentication and digital identity management, providing levels of security unmatched in the industry. In addition, the system provides new and unique methods of software piracy management including CD media-based copy protection, remote CD media validation, embedded product serialization, protection of electronically distributed software, and remote product installation tracking.

An efficient fault-tolerant event ordering service as well as a simplified approach to transaction processing based on global event ordering determines the order of interdependent operations in a distributed system. The fault-tolerant event ordering service externalizes the task of tracking dependencies to capture a global view of dependencies between a set of distributed operations in a distributed system. A novel protocol referred to as linear transactions coordinates distributed transactions with Atomicity, Consistency, Isolation, Durability (ACID) semantics on top of a sharded data store. The linear transactions protocol achieves scalability by distributing the coordination task to only those servers that hold relevant data for each transaction and achieves high performance by serializing only those transactions whose concurrent execution could potentially yield a violation of ACID semantics.

A programmable, pipelined graphics processor (e.g., a vertex processor) having at least two processing pipelines, a graphics processing system including such a processor, and a pipelined graphics data processing method allowing parallel processing and also handling branching instructions and preventing conflicts among pipelines. Preferably, each pipeline processes data in accordance with a program including by executing branch instructions, and the processor is operable in any one of a parallel processing mode in which at least two data values to be processed in parallel in accordance with the same program are launched simultaneously into multiple pipelines, and a serialized mode in which only one pipeline at a time receives input data values to be processed in accordance with the program (and operation of each other pipeline is frozen). During parallel processing mode operation, mode control circuitry recognizes and resolves branch instructions to be executed (before processing of data in accordance with each branch instruction starts) and causes the processor to operate in the serialized mode when (and preferably only for as long as) necessary to prevent any conflict between the pipelines due to branching. In other embodiments, the processor is operable in any one of a parallel processing mode and a limited serialized mode in which operation of each of a sequence of pipelines (or pipeline sets) pauses for a limited number of clock cycles. The processor enters the limited serialized mode in response to detecting a conflict-causing instruction that could cause a conflict between resources shared by the pipelines during parallel processing mode operation.

A system and a method for designing and constructing software components and systems by assembling them from independent parts which is compatible with and extends existing object models. A terminal interface and a terminal mechanism for interfacing objects is included. The mechanism is independent from the actual type of interactions established through it and allows objects to invoke directly services of other objects. All objects in a given system implement and expose a terminal interface. A property interface and mechanism with hierarchical property names and ability to execute queries is also included. The mechanism can be used for parameterization and serialization of objects, as well as to provide structured storage. A new and advantageous type of software object, named parts, is defined. Parts are constructed through an abstract factory and implement a property interface and a terminal interface.

A serialization service module is provided for configuring an asset management system to provide a secure means of generating, assigning to chips (or other electronic objects or devices), and tracking unique serial numbers. To provide this service, a controller is used to define a product model, then to define one or more serialization schemas to be bound to each product model. Each serialization schema contains a range of serial numbers for a particular product. The serial number schemas are sent over a secure, encrypted connection to appliances at the manufacturer's location. Agents can then request serial number values by product name. The serial numbers are generated by the appliance, metered, and provided to the agents. The serial numbers are then injected sequentially into each die in a chip manufacturing process using the agent.

A computer-implemented system and method for processing messages using a common interface platform supporting multiple pluggable data formats in a service-oriented pipeline architecture is disclosed. The method in an example embodiment includes deserializing or serializing a request/response message using a pluggable serializer/deserializer mechanism and a corresponding pluggable data format parser. An example embodiment uses a common model for serialization/deserialization regardless of the data format, resulting in a consistent and efficient mechanism.

A computer system includes a software virtual machine (such as Java) for running one or more applications. An object is provided that is responsive to a call from an application for placing the virtual machine and application into a state of suspension. This involves interrupting all current threads, and recording the state of the components of the virtual machine, including heap, threads, and stack, into a serialization data structure. Subsequently the serialization data structure can be invoked to resume the virtual machine and application from the state of suspension. Note that many virtual machines can be cloned from the single stored data structure. One benefit of this approach is that a new virtual machine can effectively be created in an already initialized state.

Memory allocator combines private (per thread) sets of fixed-size free blocks lists, a global, common for all threads, set of fixed-sized free block lists, and a general-purpose external coalescing allocator. Blocks of size bigger than the maximal fixed size are managed directly by the external allocator. The lengths of fixed-size lists are changed dynamically in accordance with the allocation and disallocation workload. A service thread performs updates of all the lists and collects memory associated with terminated user threads. A mutex-free serialization method, utilizing thread suspension, is used in the process.

A low pin count (LPC) input/output (I/O) bridge device and method for a portable computer having a plurality of legacy ports and a docking connector. The LPC I/O bridge device includes an LPC controller coupled to the legacy ports and docking connector. The LPC controller is adapted to detect whether the portable computer is coupled to a docking station via the docking connector and route data transmissions to the legacy ports, docking connector, or both, based on information received from an LPC interface. Serialization logic coupled to the LPC controller serializes data transmissions routed to the docking connector.

A switched file system, also termed a file switch, is logically positioned between client computers and file servers in a computer network. The file switch distributes user files among multiple file servers using aggregated file, transaction and directory mechanisms. The file switch ensures consistent and atomic behavior of the switched file system by aggregating in a deterministic way the transactions initiated by the client of multiple independent file switches so that only one of the multiple concurrent transactions attempted on the same aggregated data file may succeed, or so that the transactions are serialized so as to be performed as a sequence of atomic operations. In addition, the integrity of the aggregated data file is safeguarded by issuing locking requests on behalf of certain client applications that do not observe locking mechanism consistently.

An architecture and method is provided that facilitates serialization of a graph of objects into streams of data in an arbitrary format, and deserialization of the streams of data back into the graph of objects. The architecture provides a number of services associated with the basic functionality of serialization and deserialization. The services can be employed to implement transparent remoting, copy items to a clipboard and save data to a file. The present invention provides facilities which support the plugging in of a new serialization encoding by separating the encoding from the reading and reinstantiation of the graph of objects which the encoding describes. Objects in a graph of objects are serialized and deserialized based on a selected rule set for that object. A rule set can be provided by a class author within a class or within a third party file referred to as a surrogate.

A method for processing XML documents in a computer-based system includes associating each of a plurality of information items with a corresponding one of a plurality of binary-data units and providing a XML document associated with a XML information set comprising one or more of the plurality of information items. The method includes serializing the XML document into a binary XML format, or de-serializing the XML document from the binary XML format. Serializing includes translating the one or more information items of the XML information set into their corresponding one or more binary-data units. De-serializing includes translating one or more binary-data units of the binary XML format into their corresponding one or more information items. A computer readable medium is encoded with a program for execution on at least one processor. The program, when executed on the at least one processor, can perform the method for processing XML documents.

An apparatus and method for improving the communication capabilities of computer systems is disclosed. The most preferred embodiments of the present invention use a series of data buffers and data registers to process an incoming high speed data signal. By using the buffers and registers, the incoming signal can be reformatted and manipulated at a much lower frequency than the original transmission frequency. The deserializer of the present invention also samples a greater portion of the incoming data signal than usual to further increase reliability. These various features of the invention provide for a more stable and reliable communication link and will also provide a less expensive solution for serialization/deserialization. The present invention includes a serializer that receives parallel data input from a computer and serializes the data for transmission over a high-speed serial communication link. On the receiving end, the present invention provides a deserializer that can quickly and efficiently transform the serial data back into parallel form for use within the computer system on the receiving end. By utilizing two related clock signals, one clock signal being an integer multiple of the other, a self-synchronizing serializer/deserializer can be created. In addition, by increasing the size of the data sample on the receiving end, the comparisons necessary to retrieve a parallel signal from a serial transmission can occur at a much lower frequency than the frequency of the serial transmission. In the most preferred embodiment, the invention is provided as a integrated solution manufactured on a Peripheral Component Interconnect (PCI) card, thereby allowing the present invention to be easy installed into existing computer systems.

A DSP based SERDES performs compensation operations to support high speed de-serialization. A receiver section of the DSP based SERDES includes one or more ADCs and DSPs. The ADC operates to sample (modulated) analog serial data and to produce digitized serial data (digital representation of the modulated analog serial data). The DSP communicatively couples to the ADC and receives the digitized serial data. Based upon the known characteristics of the digitized serial data and the digitized serial data itself, the DSP determines compensation operations to be performed upon the serial data to compensate for inadequacies of the receiver and/or channel response. These compensation operations may be (1) performed on the analog serial data before digitization by the ADC; (2) applied to the ADC to modify the operation of the ADC; and/or (3) performed on the digitized serial data by the DSP or another device.

An invention for creating, sending, and using self-descriptive objects as messages over a network is disclosed. In an embodiment of the present invention, self-descriptive persistent dictionary objects are serialized and sent as messages across a message queuing network. The receiving messaging system unserializes the message object, and passes the object to the destination application. The application then queries or enumerates message elements from the instantiated persistent dictionary, and performs the programmed response. Using these self-descriptive objects as messages, the sending and receiving applications no longer rely on an a priori convention or a special-coding serialization scheme. Rather, messaging applications can communicate arbitrary objects in a standard way with no prior agreement as to the nature and semantics of message contents.

The present invention relates to exchanging data between software components in a distributed software system comprising a first software component and a second software component. A first data exchange metadata description is provided that contains information on data structures used in a serialized data exchange by the first software component. A dedicated second data exchange metadata description is provided for each older version of the second software component, each second data exchange metadata description containing information on data structures to be used in a serialized data exchange by the second software component. As a consequence, the first software component having a newer version is able to exchange data with any of the older second software components by using the respective data exchange metadata in data serialization and deserialization.

Techniques are disclosed for serializing objects (such as Java™ objects), and deserializing those objects, in a manner that enables contents of the objects to be preserved following changes to definitions of the object structures. Objects are serialized using documents encoded in a markup language (such as Extensible Markup Language, or “XML”). The serialized objects thereby capture class definition information for the class definition which was in effect when the object was serialized. Subsequently, if the class definition is changed, techniques disclosed herein enable deserializing the information from the markup language document to an object that uses the new class definition, without requiring access to a programming language specification of the now-obsolete class definition.

A method and computer program product for building a multiple layer object-oriented software application with reusable components. The method includes the steps of creating business classes containing business logic for the software application; reading templates utilizing reusable components from a template solution file; and generating programming code for the software application based on the created business classes and selected template. The multiple layers include a data layer, a data access layer, a business logic layer and a user interface layer with executable logic for each layer placed into a corresponding assembly data structure. Security tokens are required to access the classes and methods in either the business logic assembly or data access assembly. A serializable data assembly includes container classes that are used to pass data between the business logic layer and data access layer when a dataset or data table is not appropriate. A code generator user interface enables an application developer to define a namespace, a deploy directory name, a database type, an application type, a target source code directory, and a plurality of class specifications and search criteria.

A system and method for replicating a distributed computer system state among a plurality of deterministic event processing engines are disclosed. A sender module receives a plurality of input events or input event streams and generates a serialized message sequence describing an order in which input events are processed. The serialized message sequence is then transmitted to a plurality of deterministic event processing engines for processing. As the event processing engines are deterministic, each event processing engine produces the same ordered sequence responsive to the received serialized message sequence. The ordered sequences from each deterministic event processing engine are transmitted to a merger module which generates an output from the plurality of ordered sequences. The merger module removes one or more redundant ordered sequences and associates the resulting output with a client device.

Methods, systems, and computer program products for programmatically serializing complex objects (such as JavaBeans(TM)). In contrast to prior art techniques, a manually-specified data type mapping specification is not required as input to the serialization process. Instead, the present invention programmatically generates this type mapping, responsive to encountering run-time exceptions during the serialization process. The serialization process is therefore "self-healing". This approach is especially advantageous when serializing complex objects that may include complex data types and/or embedded objects. The programmatically-generated type mapping information is preferably used to generate a serialized version of the complex object, and can also be used during deserialization. In addition to improving serialization techniques, this type mapping information facilitates dynamic integration and transformation of data between heterogeneous formats.

A process for determining the compatibility of two or more versions of a single serialized class of objects residing on a data processing system is disclosed. The process is completed in a series of steps. First, two or more versions of the class are inputted into a process environment of the data processing system. Following this, each version of the class is divided into a serialized stream of elements. Finally, the stream of elements of one version of the class are compared with the stream of elements of another version of the class to find incompatible differences between the versions.

Methods, systems, and articles of manufacture consistent with certain principles related to the present invention enable a computing system to receive a serialized message including a target object that is associated with at least one member object. The computing system may invoke a deserialize method on a deserializer associated with the target object. In the event the deserialize method cannot completely deserialize the target object, the deserializer may configure a state object returned by the method to monitor a deserialization status associated with the at least one member object. The deserializer may also create an instance builder object that may complete deserialization of the target object in response to receiving a notification reflecting that the at least one member object is deserialized.

A system and method, useful in tracing program execution, for serializing data, such as an object data, into consistent, structured (e.g., XML) output. A serializer processes an object's data, and for each set of data, records the object's data in a structured (e.g., XML) format that reflects the object's current state. Nodes corresponding to fields and properties of the object are nested in the structure. Simple types define nodes with the current data value associated with the tag. More complex types including arrays, collections, dictionaries and exceptions are stored as individual members of a type, with any complex members further broken down into sub-nodes. Object data including custom collections, dictionaries, non-public fields and properties and properties with only get-accessor are serialized. The resulting output, such as in an XML formatted structure, is easy to read by humans, and is easily processed, such as for automated analysis purposes.