C++ Network Programming, Volume I: Mastering Complexity with ACE and Patterns

Description

• Copyright 2002
• Dimensions: 7-3/8" x 9-1/4"
• Pages: 336
• Edition: 1st

• Book
• ISBN-10: 0-201-60464-7
• ISBN-13: 978-0-201-60464-1

As networks, devices, and systems continue to evolve, software engineers face the unique challenge of creating reliable distributed applications within frequently changing environments. C++ Network Programming, Volume 1, provides practical solutions for developing and optimizing complex distributed systems using the ADAPTIVE Communication Environment (ACE), a revolutionary open-source framework that runs on dozens of hardware platforms and operating systems.

This book guides software professionals through the traps and pitfalls of developing efficient, portable, and flexible networked applications. It explores the inherent design complexities of concurrent networked applications and the tradeoffs that must be considered when working to master them.

C++ Network Programming begins with an overview of the issues and tools involved in writing distributed concurrent applications. The book then provides the essential design dimensions, patterns, and principles needed to develop flexible and efficient concurrent networked applications. The book's expert author team shows you how to enhance design skills while applying C++ and patterns effectively to develop object-oriented networked applications.

Readers will find coverage of:

• C++ network programming, including an overview and strategies for addressing common development challenges The ACE Toolkit
• Connection protocols, message exchange, and message-passing versus shared memory
• Implementation methods for reusable networked application services
• Concurrency in object-oriented network programming
• Design principles and patterns for ACE wrapper facades

With this book, C++ developers have at their disposal the most complete toolkit available for developing successful, multiplatform, concurrent networked applications with ease and efficiency.



Downloads

Source Code

Click below for Source Code related to this title:
Source Code



Extras

Related Article

Why Standards Alone Won't Get You Portable Software and How to Make Open-Source Middleware Work for You

Web Resources

Click below for Web Resources related to this title:
Supporting Web Site

Author's Site

Click below for Web Resources related to this title:
Author's Web Site



Sample Content

Online Sample Chapter

Design Challenges, Middleware Solutions, and ACE

Downloadable Sample Chapter

Click below for Sample Chapter related to this title:
schmidtvol1ch0.pdf

Sample Pages

Download the sample pages (includes Chapter 0 and Index)

Table of Contents

(NOTE: All chapters end with a Summary.)

About This Book.


Design Challenges, Middleware Solutions, and ACE.

Challenges of Networked Applications.

Networked Application Design Dimensions.

Object-Oriented Middleware Solutions.

An Overview of the ACE Toolkit.

Example Application: A Networked Logging Service.

I. OBJECT-ORIENTED NETWORK PROGRAMMING.

1. Communication Design Dimensions.

Connectionless versus Connection-oriented Protocols.

Synchronous versus Asynchronous Message Exchange.

Message Passing versus Shared Memory.

2. An Overview of the Socket API.

An Overview of Operating System IPC Mechanisms.

The Socket API.

Limitations of the Socket API.

3. The ACE Socket Wrapper Facades.

Overview.

The ACE Addr and ACE INET Addr Classes.

The ACE IPC SAP Class.

The ACE SOCK Class.

The ACE SOCK Connector Class.

The ACE SOCK Stream and ACE SOCK IO Classes..

The ACE SOCK Acceptor Class.

4. Implementing the Networked Logging Service.

Overview.

The ACE Message Block Class.

The ACE InputCDR and ACE OutputCDR Classes.

The Initial Logging Server.

The Client Application.

II. CONCURRENT OBJECT-ORIENTED NETWORK PROGRAMMING.

5. Concurrency Design Dimensions.

Iterative, Concurrent, and Reactive Servers.

Processes versus Threads.

Process/Thread Spawning Strategies.

User, Kernel, and Hybrid Threading Models.

Time-shared and Real-time Scheduling Classes.

Task- vs. Message-based Architectures.

6. An Overview of Operating System Concurrency Mechanisms.

Synchronous Event Demultiplexing.

MultiProcessing Mechanisms.

MultiThreading Mechanisms.

Synchronization Mechanisms.

Limitations with OS Concurrency Mechanisms.

7. The ACE Synchronous Event Demultiplexing Wrapper Facades.

Overview.

The ACE Handle Set Class.

The ACE Handle Set Iterator Class.

The ACE::select() Methods.

8. The ACE Process Wrapper Facades.

Overview.

The ACE Process Class.

The ACE Process Options Class.

The ACE Process Manager Class.

9. The ACE Threading Wrapper Facades.

Overview.

The ACE Thread Manager Class.

The ACE Sched Params Class.

The ACE TSS Class.

10. The ACE Synchronization Wrapper Facades.

Overview.

The ACE Guard Classes.

The ACE Mutex Classes.

The ACE Readers/Writer Lock Classes.

The ACE Semaphore Classes.

The ACE Condition Variable Classes.

A Design Principles for ACE C++ Wrapper Facades.

Overview.

Use Wrapper Facades to Enhance Type Safety.

Simplify for the Common Case.

Use Hierarchies to Enhance Design Clarity and Extensibility.

Hide Platform Differences Whenever Possible.

Optimize for Efficiency.

B The Past, Present, and Future of ACE.

The Evolution of ACE.

The Road Ahead.

Concluding Remarks.

Glossary.
Index. 0201604647T12052001

Preface

Over the past decade, concurrent object-oriented network programming has emerged as an effective paradigm for developing software applications whose collaborating objects can either be

1. Collocated within one process or computer or
2. Distributed across a set of computers connected by a network, such as an embedded system interconnect, a local area network (LAN), an enterprise intranet, or the Internet.

When objects are distributed, the various entities that constitute these objects must communicate and coordinate with each other effectively. Moreover, they must continue to do so as applications change over their lifetimes. The placement of objects, the available networking infrastructure, and platform concurrency options allow for a level of freedom that's powerful, yet challenging.

When designed properly, concurrent object-oriented network programming capabilities can add a great deal of flexibility to your application options. For instance, in accordance with the requirements and resources available to your projects, you can use

• Real-time, embedded, or handheld systems
• Personal or laptop computers
• An assortment of various-sized UNIX or Linux systems
• "Big iron" mainframes and even supercomputers

You'll likely encounter complex challenges, however, when developing and porting networked applications on multiple operating system (OS) platforms. These complexities appear in the form of incompatible networking protocols or component libraries that have different APIs and semantics on different hardware and software platforms, as well as accidental complexities introduced by limitations with the native OS interprocess communication (IPC) and concurrency mechanisms themselves. To alleviate these problems, the ADAPTIVE Communication Environment (ACE) provides an object-oriented toolkit that runs portably on dozens of hardware and OS platforms, including most versions of Win32 and UNIX, as well as many real-time and embedded operating systems.

Some would have you believe that de facto or de jure OS standards, such as POSIX, UNIX98, or Win32, are all programmers need to shield their applications from portability challenges. Unfortunately, the adage that "the nice thing about standards is that there are so many to choose from" is even more applicable today than it was a decade ago. There are now dozens of different OS platforms used in commercial, academic, and governmental projects, and the number of permutations grows with each new version and variant.

We've developed many multiplatform, concurrent, and networked systems for the past two decades. We can therefore assure you that OS vendors often choose to implement different standards at different times. Moreover, standards change and evolve. It's likely that you'll work on multiple platforms that implement different standards in different ways at different times. Programming directly to OS APIs therefore yields the following two problems:

1. It's error-prone since native OS APIs written in C often lack typesafe, portable, reentrant, and extensible system function interfaces and function libraries. For example, endpoints of communication in the widely used Sockets API (discussed in Chapter 2) are identified via weakly typed integer or pointer I/O handles, which increase the likelihood of subtle programming errors at run-time.
2. It encourages inadequate design techniques since many networked applications written using OS APIs are based upon algorithmic design, rather than object-oriented design. Algorithmic design decomposes the structure of an application according to specific functional requirements, which are volatile and likely to evolve over time. This design paradigm therefore yields nonextensible software architectures that can't be customized rapidly to meet changing application requirements.

In this age of economic upheaval, deregulation, and stiff global competition, it's becoming prohibitively expensive and time consuming to develop applications entirely from scratch using native OS APIs and algorithmic design techniques.

If you've been developing networked software systems for many years, you may have learned to accept some of these problems as a fact of life. There is a better way, however. In this book, we show how C++ and ACE provide object-oriented capabilities that allow you to avoid many traps and pitfalls, while still leveraging standards--and even certain platform-specific features--whenever possible. Object-oriented designs exhibit greater stability over time than algorithmic designs, which makes them the preferred basis for developing many types of networked applications.

Not surprisingly, there's a price for all this flexibility: you may need to learn some new concepts, methods, patterns, tools, and development techniques. Depending on your background, this learning curve may be trivial or it may initially seem steep. The bottom line, however, is that the object-oriented paradigm can offer you a mature set of techniques that alleviates many challenges of networked application development. This book presents a series of concrete examples to illustrate the object-oriented techniques used to develop and apply the classes in the ACE toolkit. You can use the same techniques and ACE classes to simplify your own applications.

Intended Audience

This book is intended for "hands-on" developers or advanced students interested in understanding the strategies and tactics of concurrent network programming using C++ and object-oriented design. We describe the key design dimensions, patterns, and principles needed to develop flexible and efficient concurrent networked applications quickly and easily. Our numerous C++ code examples reinforce the design concepts and illustrate concretely how to use the core classes in ACE right away. We also take you "behind the scenes" to understand how and why the IPC and concurrency mechanisms in the ACE toolkit are designed the way they are. This material will help to enhance your design skills and to apply C++ and patterns more effectively in your own object-oriented networked applications.

This book is not a comprehensive tutorial on object-oriented development, patterns, UML, C++, systems programming, or networking. We therefore assume readers of this book have some familiarity with the following topics:

• Object-oriented design and programming techniques, for example, frameworks, patterns, modularity, information hiding, and modeling
• Object-oriented notations and processes, such as the Unified Modeling Language (UML), eXtreme Programming, and the Rational Unified Process (RUP)
• Fundamental C++ language features, such as classes, inheritance, dynamic binding, and parameterized types
• Core systems programming mechanisms, such as event demultiplexing, process and thread management, virtual memory, and IPC mechanisms and APIs commonly available on UNIX and Win32 platforms
• Networking terminology and concepts, such as TCP/IP, remote operation invocations, and client/server architectures

We encourage you to use the extensive bibliography to locate sources of information on topics about which you want to learn more.

This book is also not an ACE programmer's manual; that is, we don't explain every method of every class in ACE. For that level of detail we refer you to the extensive online ACE documentation, generated by Doxygen. at http://ace.ece.uci.edu/Doxygen/ and http://www.riverace.com/docs/. Instead, this book focuses on

• The key concepts, patterns, and C++ features that shape the design of successful object-oriented networked applications and middleware and
• The motivation behind, and basic usage of, the most commonly used ACE TCP/IP and concurrency wrapper facade classes

Structure and Content

This book describes how C++ and middleware help address key challenges associated with developing networked applications. We review the core native OS mechanisms available on popular OS platforms and illustrate how C++ and patterns are applied in ACE to encapsulate these mechanisms in class library wrapper facades that improve application portability and robustness. The book's primary application example is a networked logging service that transfers log records from client applications to a logging server over TCP/IP. We use this service as a running example throughout the book to

• Show concretely how C++ and ACE can help achieve efficient, predictable,
• and scalable networked applications and
• Demonstrate key design and implementation considerations and solutions that will arise when you develop your own concurrent object-oriented networked applications

The book is organized into 11 chapters as follows:

• Introduction--Chapter 0 presents an introduction to C++ network programming. It starts by outlining the problem space and presenting the challenges that can arise when applications extend beyond a single thread in a single process. We then introduce a taxonomy of middleware layers and describe how host infrastructure middleware and the ACE toolkit can be applied to address common network programming challenges.
• Part I--Chapters 1 through 4 outline communication design alternatives and describe the object-oriented techniques used in ACE to program OS IPC mechanisms effectively. The resulting classes form the basis of the first version of the book's running example, a networked logging service.
• Part II--Chapters 5 through 10 outline concurrency design alternatives and describe the object-oriented techniques used in ACE to program OS concurrency mechanisms effectively.

Throughout Parts I and II we present a series of increasingly sophisticated implementations of our networked logging service to illustrate how the ACE IPC and concurrency wrapper facades can be applied in practice.

Appendix A summarizes the class design and implementation principles that underlie the ACE IPC and concurrency wrapper facades. Appendix B explains the inception and open-source evolution of ACE over the past decade and outlines where it's heading in the future. The book concludes with a glossary of technical terms (including the italicized terms in this book), an extensive list of references for further research, and a general subject index.

Related Material

This book focuses on resolving complexity using specific C++ features, patterns, and ACE. The second volume in this series--C++ Network Programming: Systematic Reuse with ACE and Frameworks--extends our coverage to include object-oriented network programming frameworks provided by ACE. These frameworks reify common usage patterns of the ACE wrapper facade classes presented in this book to support broader, more extensible levels of systematic reuse. A distinguishing factor between the ACE wrapper facade classes covered in this book and the ACE framework classes covered in Volume 2 is that the ACE wrapper facade classes have few virtual methods, whereas the ACE framework classes have mostly virtual methods.

This book is based on ACE version 5.2, released in October 2001. The ACE software and all the sample applications described in our books are open-source and can be downloaded at http://ace.ece.uci.edu and http://www.riverace.com. These sites also contain a wealth of other material on ACE, such as tutorials, technical papers, and an overview of other ACE wrapper facades for IPC and synchronization mechanisms that aren't covered in this book. We encourage you to obtain a copy of ACE so you can follow along, see the actual ACE classes and frameworks in complete detail, and run the code examples interactively as you read through the book. Precompiled versions of ACE can also be purchased at a nominal cost from http://www.riverace.com.

To learn more about ACE, or to report any errors you find in the book, we recommend you subscribe to the ACE mailing list, ace-users@cs.wustl.edu. You can subscribe by sending e-mail to the Majordomo list server at ace-users-request@cs.wustl.edu. Include the following command in the body of the e-mail (the subject line is ignored):

subscribe ace-users emailaddress@domain

You must supply emailaddress@domain only if your message's From address is not the address you wish to subscribe. Postings to the ACE mailing list are also forwarded to the USENET newsgroup comp.soft-sys.ace. Archives of postings to the ACE mailing list are available at http://groups.yahoo.com/group/ace-users.

0201604647P12052001

Index

Click below to download the Index file related to this title:
Index



Updates

Submit Errata

