Showing papers on "Serialization published in 2001"

Speculative lock elision: enabling highly concurrent multithreaded execution

Abstract: Serialization of threads due to critical sections is a fundamental bottleneck to achieving high performance in multithreaded programs. Dynamically, such serialization may be unnecessary because these critical sections could have safely executed concurrently without locks. Current processors cannot fully exploit such parallelism because they do not have mechanisms to dynamically detect such false inter-thread dependences. We propose Speculative Lock Elision (SLE), a novel micro-architectural technique to remove dynamically unnecessary lock-induced serialization and enable highly concurrent multithreaded execution. The key insight is that locks do not always have to be acquired for a correct execution. Synchronization instructions are predicted as being unnecessary and elided. This allows multiple threads to concurrently execute critical sections protected by the same lock. Misspeculation due to inter-thread data conflicts is detected using existing cache mechanisms and rollback is used for recovery. Successful speculative elision is validated and committed without acquiring the lock. SLE can be implemented entirely in microarchitecture without instruction set support and without system-level modifications, is transparent to programmers, and requires only trivial additional hardware support. SLE can provide programmers a fast path to writing correct high-performance multithreaded programs.

Synchronous collaboration based on peer-to-peer communication

Abstract: A peer-to-peer protocol is based on the use of global timestamps and client priorities in serializing modifications to a shared workspace of real-time collaboration. The method caters to dynamic clients wherein a client can leave or join an ongoing collaboration session as long as there is always at least one client present/remaining in the collaboration session. The method can support multiple definitions of a modification, including partitioning-based definitions, wherein the method provides full support for locking of partitions, and a full treatment of inter-partition synchronization via a modification definition over multiple partitions. The method is capable of utilizing the many standard methods of creating a global, distributed, synchronized clock for the global timestamps utilized by it. The method is rollback-based for correcting tentative but incorrect serializations, and provides additional backup in terms of checkpoints for additional safety and for the support of lightweight, pervasive clients. The method includes many optimizations for efficiency, and includes a method of switching to and back from distributed server-based serialization for the periods when the network response is better suited to a distributed server than the peer-to-peer protocol.

On objects and events

Abstract: This paper presents linguistic primitives for publish/subscribe programming using events and objects. We integrate our primitives into a strongly typed object-oriented language through four mechnisms: (1) serialization, (2) multiple subtyping, (3)closures, and (4) deferred code evaluation. We illustrate our primitives through Java, showing how we have overcome its respective lacks. A precompiler transforms statements based on our publish/subscribe primitives into calls to specifically generated typed adapters, which resemble the typed stubs and skeletons by the rmic precompiler for remote method invocations in Java

Methods and systems for the order serialization of information in a network processing environment

Abstract: A multi-processor network processing environment is provided in which parallel processing may occur. In one embodiment, a network processor having multiple processor cores may be utilized. Parallel processing at the front end of the network processor is encouraged while still maintaining ordered serialization between the input and the output of the network processor. The disclosed order serialization techniques obtain the benefits of parallel processing at the front end of the system while minimizing blocking times at the output.

Java RMI

Abstract: From the Publisher: Java RMI contains a wealth of experience in designing and implementing Java's Remote Method Invocation. If you're a novice reader, you will quickly be brought up to speed on why RMI is such a powerful yet easy to use tool for distributed programming, while experts can gain valuable experience for constructing their own enterprise and distributed systems. With Java RMI, you'll learn tips and tricks for making your RMI code excel. The book also provides strategies for working with serialization, threading, the RMI registry, sockets and socket factories, activation, dynamic class downloading, HTTP tunneling, distributed garbage collection, JNDI, and CORBA. In short, a treasure trove of valuable RMI knowledge packed into one book.

Architecture and method for serialization and deserialization of objects

Abstract: 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.

System architecture for medical imaging systems

Abstract: A medical imaging system includes a workstation for receiving operator inputs that prescribe a scan and a plurality of servers which control the acquisition of image data and the reconstruction of prescribed images. The workstation is programmed in Java™ to produce scan descriptions that are downloaded to the servers prior to run time using a serialization mechanism.

Transaction Timestamping in (Temporal) Databases

Abstract: Many database applications need accountability and trace-ability that necessitate retaining previous database states. For a transaction-time database supporting this, the choice of times used to timestamp database records, to establish when records are or were current, needs to be consistent with a committed transaction serialization order. Previous solutions have chosen timestamps at commit time, selecting a time that agrees with commit order. However, SQL standard databases can require an earlier choice because a statement within a transaction may request “current time.” Managing timestamps chosen before a serialization order is established is the challenging problem we solve here. By building on two-phase locking concurrency control, we can delay a transaction’s choice of a timestamp, reducing the chance that transactions may need to be aborted in order keep timestamps consistent with a serialization order. Also, while timestamps stored with records in a transaction-time database make it possible to directly identify write-write and write-read conflicts, handling read-write conflicts requires more. Our simple auxiliary structure conservatively detects read-write conflicts, and hence provides transaction timestamps that are consistent with a serialization order.

Hardware-enforced control of access to memory within a computer using hardware-enforced semaphores and other similar, hardware-enforced serialization and sequencing mechanisms

Abstract: Method and system for providing hardware-enforced synchronization and serialization mechanisms, such as semaphores, to allow for control of access to memory regions within a computer system. In addition to the traditional semaphore protocol, hardware enforced semaphores are associated with memory regions and with protection keys selected from a pool of protection keys that control access to those memory regions. Hardware-enforced semaphores control insertion and deletion of protection keys from protection-key registers and internal data structures in order to enforce access grants provided by the semaphore protocol.

Inter-process communication using different programming languages

Abstract: A Java client M1140 offers an interface Random M1140 to its users. Instead of the usual RMI/serialization communication, the code in M1140 does RPC/XDR communication. This makes it possible to exchange data with an RPC server M3110, which has C code, e.g. as shown at M3111, forming a C language equivalent of the Java instruction within object M1141. In the example, process M3110 has to return object diode 1. For so doing, its code includes e.g. a lookup(name) where name is the parameter of the random gen() function, i.e. diode 1. The lookup interrogates an object dictionary M3160. The dictionary has information about the data structure diode 1, as shown at M3162; it may therefore return diode1, i.e. the ( )address of the data structure (or C object) diode 1, to process M3110, for retransmission to Java client M1140. Other alternatives are described, including the reciprocal intercommunication.

Using embedded identifiers with images

Abstract: Digital watermarking technology is used in conjunction with map data, such as is acquired by satellite and other aerial sensors. The watermarks are used to track metadata, provide serialization and forensic tracking, help auto-correlate image data, and quilt together related imagery. One aspect of the present invention contemplates that incoming imagery is automatically geo-referenced and combined with previously collected data sets so as to facilitate generation of revised composite maps. Another aspect of the present invention associates geovector information with a photograph via a digital watermark.

Web browser of wireless device having serialization manager for maintaining registry of converters that convert data into format compatible with user interface of the device

Abstract: An information browser system and method enables sending of information requests to remote information sources and receiving of requested information from the remote sources on a wireless communication device. Information in any of a plurality of formats, including WML, HTML and WMLScript, is converted into a format in which the information can be displayed or otherwise further processed by the device. Information browsing functions may also be integrated with other communication functions on a mobile communication device.

Design of an optimal test access architecture using a genetic algorithm

Abstract: Test access is a major problem for core-based system-on-chip (SOC) designs. Since cores in an SOC are not directly accessible via chip inputs and outputs, special access mechanisms are required to test them at the system level. One of the most important issues in designing a test access architecture is testing time. Here, several issues related to the design of an optimal test access architecture with the goal of minimizing testing time are discussed. These issues include the assignment of cores to test buses, the distribution of test data width between multiple test buses, and the estimation of test data requirements to satisfy an upper bound on the testing time. Previous works show that all of these problems are NP-complete. Here, we applied a genetic algorithm (GA) to solve these problems. Experiments were run on two hypothetical but non-trivial SOCs using the implemented GA. The results show a 40% improvement. The performance improvement is principally due to our removing the constraints of the necessity of serialization and allowing the system to handle serial or parallel test data loading for any core.

Java virtual machine support for object serialization

Abstract: Distributed computing has become increasingly popular in the high performance community. Java's Remote Method Invocation (RMI) provides a simple, yet powerful method for implementing parallel algorithms. The performance of RMI has been less than adequate, however, and object serialization is often identified as a major performance inhibitor. We believe that object serialization is best performed in the Java Virtual Machine (JVM), where information regarding object layout and hardware communication resources are readily available. We implement a subset of Java's object serialization protocol in native code, using the Java Native Interface (JNI) and JVM internals. Experiments show that our approach is up to eight times faster than Java's original object serialization protocol for array objects. Also for linked data structures, our approach obtains a moderate speedup and better scalability. Evaluation of our object serialization implementation in an RMI framework indicates that a higher throughput can be obtained. Parallel applications, written using RMI, obtain better speedups and scalability when this more efficient object serialization is used.

Object Serialization and Deserialization Using XML

Abstract: Interoperability of potentially heterogeneous databases has been an ongoing research issue for a number of years in the database community. With the trend towards globalization of data location and data access and the consequent requirement for the coexistence of new data stores with legacy systems, the cooperation and data interchange between data repositories has become increasingly important. The emergence of the eXtensible Markup Language (XML) as a database independent representation for data offers a suitable mechanism for transporting data between repositories. This paper describes a research activity within a group at CERN (called CMS) towards identifying and implementing database serialization and deserialization methods that can be used to replicate or migrate objects across the network between CERN and worldwide centres using XML to serialize the contents of multiple objects resident in object-oriented databases.

ZR: A 3Dd API transparent technology for chunk rendering

Abstract: This paper presents ZR (Zone Rendering), a 3D graphics technology that addresses ever-increasing bandwidth requirements using chunk rendering technique, and at the same time solves 3D API compatibility issues commonly associated with chunk rendering graphics devices. We apply a pipeline serialization technique to handle the cases causing compatibility issues. However, excessive frequency of serializations may offset the performance advantage of ZR. In order to manage potential performance problems we developed software and hardware techniques to optimize ZR performance for most events that might cause the serialization. Comprehensive validation experiments were conducted for popular 3D applications to show that after the optimizations the residual impact of the serialization is very small. Finally, using the results of Intel® 830 graphics, which implements ZR, we demonstrate that ZR provides significant 3D graphics performance improvement. This result is achieved within a limited bandwidth budget, and at the cost of modest micro-architectural changes to traditional graphics pipeline.

Persistent object management

Abstract: The invention relates to persistent object management and serialization. Serialization is minimized by only storing those objects that have been modified, created or deleted since the last save operation and not objects that are referenced by these modified objects. This is generally accomplished by keeping track, in an object persistence manager (120), of modified objects and storing, for each modified object, the object state together with identification of possible referenced objects in a persistent storage medium (140). At restoration, the objects are restored individually from the persistent storage (140). In order to restore the relationship between objects, the object persistence manager (120) is not only notified of completed restoration of individual objects, but also informed of which objects that are referenced and hence needed by the individually restored objects. Once a referenced object has been restored, the object persistence manager (120) is thus capable of notifying the object that needs the referenced object that restoration of the needed object has been completed and that the actual reference between the objects can be set. The fact that only modified objects are stored minimizes the required serialization and improves the redundant storage performance significantly.

Rule-Based Transactional Object Migration over a Reflective Middleware

Abstract: Object migration is an often overlooked topic in distributed object-oriented platforms. Most common solutions provide data serialization and code mobility across several hosts. But existing mechanisms fall short in ensuring consistency when migrating objects, or agents, involved in coordinated interactions with each other, possibly governed by a multi-phase protocol. We propose an object migration scheme addressing this issue, implemented on top of the Coordination Language Facility (CLF). It exploits the particular combination of features in CLF: the resource-based programming paradigm and the communication protocol integrating a negotiation and a transaction phase. We illustrate through examples how our migration mechanism goes beyond classical solutions. It can be fine-tuned to consider different requirements and settings, and thus be adapted to a variety of situations

Transactional COM+: Building Scalable Applications

Abstract: 1. Scalability. Scalability Basics. Identity. Identity in COM. Sharing Identities. Implementing Named Objects. The Problem with Sharing COM Objects. Identity Revisited. Implementing Named Objects with Key-Based Logical Identity. Implementing Named Objects on Top of a Database. What Has Been Gained? The Object-per-Client Model. Transactions. Enter Transactions. Clients and TMs and RMs, Oh My! Local Transactions and Distributed Transactions. The Transactions and Scalability Paradox. Integrating Objects and Transactions. Using Transactions Explicitly. Using Transactions Implicitly. Applying Transactions. Thinking about Roundtrips. A Complex Problem. A Possible Solution. A Much Better Solution. Thinking about Roundtrips Again. Processor Objects. Summary. 2. Atoms. The Linker Switch Story. An Experiment. The Windows Process Loader. How COM+ Works. From Consoles to Contexts. Cross-Context Calls. Contexts as Objects. Object Context Interfaces. Using Object Context. Where Do Contexts Come From? The Catalog. Applications. Libraries and Servers. Why Library Applications? Configured Classes. Custom Attributes. Changing the Contents of the Catalog. Context Flow. Causality. How Causality Works. Causalities as Objects. Call Context Interfaces. Using Call Context. Summary. 3. Mechanics. Context Relativity. The Problem. Marshaling Interface Pointers. The Global Interface Table. Context Relativity in Day-to-Day Life. The Cost of Contexts. A Context for Every Object. The Cost of Contexts in Time. The Cost of Contexts in Space. Are Contexts Worth the Price? Limiting Context. Nonconfigured Classes. Raw-Configured Classes. Context-Aware Code Revisited. A Different Way of Looking at the World. Subtle Complexities. Custom Marshaling. Some Other Observations. Summary. 4. Threads. Apartments. Apartment Types. Where Do Apartments Come From? Threading Models. Default Contexts. Remote Object Creation. Cross-Apartment Calls. STA Complexities. Cross-Apartment Call Overhead. Apartment Guidelines. Raw-Configured Classes Revisited. Activities. Enter Activities. Where Do Activities Come From? Detecting the Presence of an Activity. Allocating STA Objects to Apartments. Serializing Calls. Activity Reentrancy. Activity Deadlock. Activity Guidelines. Summary. 5. Objects. Object Pooling. Enabling Object Pooling. Reusing Objects. Controlling the Size of a Class's Pool. Implementing Pooled Classes. Accessing Context. Managing Resources. The GIT Trick (and Why It Doesn't Work). An Exception to the Rules. Object Pooling Guidelines. Just-in-Time Activation. Enabling JITA. How JITA Works. Flipping the Done Bit. The AutoComplete Attribute. JITA Notifications. JITA Guidelines. Lies, Damn Lies, and Statistics. Summary. 6. Transactions. Local Transactions. OLE DB. Higher Level APIs. Distributed Transactions. Enter the Distributed Transaction Coordinator. Starting a Distributed Transaction. Enlisting a Connection. The Two-Phase Commit Protocol. Distributed Transaction Complexities. Distributed Transaction Propagation. Connection Management. A Race Condition. Declarative Transactions. Transactional Objects. Enter Transaction Streams. Where Do Transaction Streams Come From? Detecting the Presence of a Transaction Stream. Creating and Propagating a Distributed Transaction. Autoenlisting Connections. Controlling a Declarative Transaction's Outcome. Flipping the Happy Bit. The Four Possible States of a Transactional Object. Root Objects and HRESULTs. Transaction Stream Caveats. Transaction Guidelines. Summary. 7. Isolation. Correctness versus Performance. Five Degrees of Isolation. Implementing Isolation Using Locks. Implementing Isolation Using Versions. Choosing an Isolation Level. Isolation-Level Guidelines. Specifying Isolation Levels. Isolation Levels and OLE DB. Isolation Levels and the DTC. Isolation Levels and COM+. Bring Your Own Transaction. ISOFLAGs. Deadlocks. Avoiding Deadlocks. Detecting Deadlocks. Timeouts and the DTC. Timeouts and COM+. Timeouts and OLE DB. Application-Level Isolation. Optimistic Application-Level Locking. Pessimistic Application-Level Locking. Summary. 8. Protocols. HTTP. HTTP Messages. HTTP Connection Management. Internet Information Server. Mapping Requests to Files. Mapping Requests to Processes. Mapping Requests to Contexts and Apartments. Processing Requests in Parallel. Active Server Pages. Processing ASP Requests. Transactional Pages. Transaction Outcome Notifications. Server.Execute and Server.Transfer. ASP Pages and Raw-Configured Classes. ASP Pages and Object Context. HTTP + XML = RPC. SOAP Messages. SOAP and HTTP. Applying SOAP. Message Queuing. Transactional Messaging. Applying Message Queuing. Summary. 9. Design. Machines, Processes, and Protocols. Machine Architecture. Process Architecture. Protocols. Processors and Helpers. A Simple Logical Model. A Simple Physical Model. Accessing Processors via HTTP. Transactions and Data Access. Accessing Data Efficiently. Middle-Tier State. Some Final Advice. Appendix A: Toward .NET. Appendix B: Building a Better Connection Pool. An Example. IObjectConstruct. IObjectControl. IConn. Using a Pooled Connection. Source Code. Appendix C: Debugging. Appendix D: Catalog Attributes and Component Services Explorer Property Pages. Application Property Pages. Class Property Pages. Interface Property Pages. Method Property Pages. Rules. Summary. Index. 0201615940T04062001

Type conversion technique facilitating remote service invocation

Abstract: The present invention, generally speaking, provides a messaging framework (101) including a flexible type conversion facility (107, 111) for use in remote method invocation via the Internet. When the framework (101) receives a message, a request message decoder (105) decodes the message; a tag conversion routine (107) converts any parameters into objects, locates the appropriate message handler; and an invoker module (107) invokes the requested method on that handler, and communicates a return value (or exception) via a response message. In the case of the SOAP protocol, for example, the return value (or exception) is encoded into XML and wrapped in a SOAP protocol response message. Dynamic type conversion (111) of parameters into objects is performed using a tag library system (107). In the tag library system (107), special user-defined modules (115) (called "type factories") are handed XML elements for conversion into objects. Unlike a strictly type-conversion architecture such as classic object serialization, there are no dependencies between the XML input and the objects produced by the type factory. Furthermore, the factory is not required to extract all of the content during a conversion, but can pass the raw XML content to the constructed object for later use.

Concurrency control for mobile systems with data broadcast

Abstract: Although data broadcast has been shown to be an efficient method for disseminating data items in a mobile computing system with large number of clients, the issue on how to ensure the data consistency observed by mobile transactions, which are generated by mobile clients, has been largely ignored by researchers in the area. While data items are being broadcast, update transactions may install new values for the data items. If the executions of update and broadcast of data items are interleaved without any control, the mobile transactions may observe inconsistent data values. In this paper, we propose a serialization checking method (SCM) for concurrency control between read-only mobile transactions and update transactions. SCM is based on the framework of an earlier algorithm, Update First with Ordering (UFO), but improves on that algorithm by reducing re-broadcast overhead when the probability of data conflict between updates and data broadcast is high. Simulation experiments have been performed to investigate the performance characteristics of the proposed method.

Parallelization of a Hyper-Linking–Based Theorem Prover

Abstract: We describe the parallelization of a first-order logic theorem prover that is based on the hyper-linking proof procedure (HLPP). Four parallel schemes – process level, clause level, literal level, and flow level – are developed for two types of sequential implementation of HLPP: list based and network based. The motivation for developing each parallel scheme is presented, and the architecture and implementation details of each scheme are described. Issues about parallel processing, such as serialization and synchronization, load balancing, and access conflicts, are examined. Speedups over sequential implementations are attained, and timing results for benchmark problems are provided.

Excessive spin detection and avoidance for systems using a least recently used page replacement algorithm

Abstract: A system and method for eliminating excessive spin conditions on systems implementing a LRU algorithm. This is achieved by limiting the amount of time a LRU task is allowed to run in any one invocation. If this time limit is exceeded before the LRU task has completed its processing, the LRU task will reschedule itself to run after a short time interval, record which frames have been processed so far, release its serialization resources, and exit to open a window of enablement. During this window, other processes that were spinning for the serialization resources can have a chance to run. When the LRU task runs again it will re-obtain the serialization resources and continue processing frames that were not previously processed. The above process will be repeated until all the appropriate frames in the system are in LRU order.

Linguistic Support for Large-Scale Distributed Programming

Abstract: We present three operators for the expression of event-based large-scale distributed programming. In short, these operators support a publish/subscribe-based interaction scheme, leading to a distributed object programming model merging the benefits of objects and events. For the integration of our operators into a strongly typed object-oriented language we identify a set of four concepts, roughly (1) serialization, (2) multiple subtyping, (3) multi-methods, and (4) closures, which provided by a language, enable its smooth integration with our model of publish/subscribe interaction. These concepts are illustrated through Java, which we augment by anonymous methods, a simple form of closures, and in which we use double dispatch to make up for the lack of multi-methods. A precompiler transforms code related to our publish/subscribe operators into calls to specifically generated typed adapters, which are similar to typed stubs/skeletons for remote method invocations.

C++ In Action: Industrial Strength Programming Techniques

Abstract: (NOTE: Most chapters include a Summary and Conclusion, and Exercises.) Preface. Why This Book? Why You? Why Me? Acknowledgment. Introduction. Language. Techniques. Windows. Scaling Up. How to Use This Book. Version Control System. Compiler. Code Samples. Typeface Conventions. I. LANGUAGE. 1. Objects and Scopes. Global Scope. Local Scope. Embedded objects. Inheritance. Member Functions and Interfaces. Member Function Scope. Types. Abstract Data Types. 2. Arrays and References. References. Operators. Arithmetic. Logic. Bitwise Logic. Stack-Based Calculator. External Specification. Design. Stubbed Implementation. Implementation. Calculator: Implementation. Input: Implementation. 3. Pointers. Evils of Pointers. Pointers versus References. Pointers versus Arrays. Assembly Digression. Pointers and Dynamic Memory Allocation. Dynamic Data Structures. Dynamic Stack. Linked List. String Table. String Buffer. Table Lookup. Hash Table. Test Program. 4. Polymorphism. The Meaning of is-a. Implementation Digression. The Overhead. Parse Tree. C Digression. 5. A Small Software Project. Starting a Software Project. Design Specification. Stubbed Implementation. Expanding Stubs. Final Implementation. Not! Scanner. Symbol Table. Store. Function Table. Nodes. Parser. Main. Initialization of Aggregates. Procedural Programming. Operator Overloading. Passing by Value. Value Semantics. II. TECHNIQUES. 6. The Cleanup. Decoupling the Output. Fighting Defensive Programming. A Case of Paranoid Programming. Fringes. Improving Communication between Classes. Correcting Design Flaws. 7. Hiding Implementation Details. Using Embedded Classes. Combining Classes. Combining Things Using Namespaces. Hiding Constants in Enumerations. Hiding Constants in Local Variables. 8. Sharing. Isolating Global Program Parameters. Pushing the Envelope. Templates. 9. Removing Limitations. Dynamic Array. Dynamic MultiNode. Dynamic StringBuffer. Dynamic SymbolTable. Dynamic Store. Standard Vector. 10. Resource Management. Exceptions. Stack Unwinding. Resources. Ownership of Resources. Access to Resources. Smart Pointers. Ownership Transfer: First Attempt. Ownership Transfer: Second Attempt. Safe Containers. Iterators. Error Propagation. Conversion to Resource Management. Conclusion. 11. Using the Standard Template Library. Reference Counting and Copy-On-Write. End of Restrictions. Getting Rid of C-String. Exploring Streams. 12. Persistence. The Calculator Object. Command Parser. Serialization and Deserialization. In-Memory Serialization and Deserialization. Multiple Inheritance. 13. Overloading Operator new. Class-Specific new. Caching. Bulk Allocation. Array new. Global new. Macros. Tracing Memory Leaks. Debug Output. Placement new. Conclusion. III. WINDOWS. 14. Libraries. Of Macros and Wizards. 15. Programming Paradigm. Hello Windows! Encapsulation. 16. Controlling Windows through C11. Model-View-Controller. Controller. Client Code. Exception Specification. Cleanup. 17. Painting. Application Icon. Window Painting and the View Object. The Canvas. The WM_PAINT Message. The Model. Capturing the Mouse. Adding Colors and Frills. 18. A Windows Application. Porting the Calculator to Windows. User Interface. Child Windows. Windows Controls. Static Text. Edit Control. Window Subclassing. Plugging in the Calculator. List Box Control. Model-View Feedback Loop. Commands and Menus. Dynamic Menus. Dialog Boxes. IV. SCALING UP. 19. About Software. Complexity. The Fractal Nature of Software. The Living Project. The Living Programmer. 20. Design Strategies. Top-Down Object-Oriented Design. User Interface. Requirement Specification. Architectural Specification. 21. Team Work. Productivity. Team Strategies. 22. Implementation Strategies. Global Decisions. Top-Down Object-Oriented Implementation. Program Modifications. Inheriting Legacy Code. Multi-Platform Development. 23. Porting. Creating an Abstraction Layer. Porting the Calculator. Eliminating Simple Windows Dependencies. Nontrivial Windows Dependencies. The Advantages of Porting. Bibliography. Appendix A: Exercise Solutions. Appendix B: Transactions. Transient Transactions. Persistent Transactions. The Three-File Scheme. The Mapping-File Scheme. Index. 0201699486T05212002

BCA writer serialization management

Abstract: A serialization management system consists of a job control host for assigning serial numbers to storage media, and for generating a job; a replication facility host communicatively coupled to the job control host, wherein the job control host communicates the job to the replication facility host; and a serialization writer communicatively coupled to the replication facility host, wherein the replication facility host controls the serialization writer in response to the job, and communicates status information to the job control host. In another embodiment, the invention can be characterized as method for operating the serialization management system.

The push architecture: a prefetching framework for linked data structures

Abstract: The widening performance gap between processors and memory makes techniques that alleviate this disparity essential for building high-performance computer systems. Caches are recognized as a cost-effective method to improve memory system performance. However, a cache's effectiveness can be limited if programs have poor locality. Thus techniques that hide memory latency are essential to bridging the CPU-memory gap. Prefetching is a commonly used technique to overlap memory accesses with computation. Prefetching for array-based numeric applications with regular access patterns has been well studied in the past decade. However, prefetching for pointer-intensive applications remains a challenging problem. Prefetching linked data structures (LDS) is difficult because address sequences do not present the same arithmetic regularity as array-based applications and because data dependence of pointer dereferences can serialize the address generation process. The push architecture proposed in this thesis is a cooperative hardware/software prefetching framework designed specifically for linked data structures. The push architecture exploits program structure for future address generation instead of relying on past address history. It identifies the load instructions that traverse a LDS and uses a prefetch engine to execute them ahead of the CPU execution. This allows the prefetch engine to successfully generate future addresses. To overcome the serial nature of LDS address generation, the push architecture employs a novel data movement model. It attaches the prefetch engine to each level of the memory hierarchy and pushes, rather than pulls, data to the CPU. This push model decouples the pointer dereference from the transfer of the current node up to the processor. Thus a series of pointer dereferences becomes a pipelined process rather than a serial process. Simulation results show that the push architecture can reduce up to 100% of memory stall time on a suit of pointer-intensive applications, reducing overall execution time by an average 19%.

TV Decoder has external access for memory reset voltage avoids serialization of faulty units

Abstract: The TV decoder has an interface card (10) close to the box wall which can be contacted from outside by pins (18) from a 12 V generator (19) which enables the writing of serial number and other data into the protected part (8) of the memory (4)