bull; An intro guide for ACE beginners, and an authoritative reference for all ACE users. bull; Foreword by Dr. Douglas C. Schmidt--the original developer of ACE. bull; ACE is an excellent example of how to design object-oriented software and use C++ to design and write high-performance, easily maintained software systems.

Stephen D. Huston is President and CEO of Riverace Corporation, a provider of technical support and consulting services to companies who want to keep software projects on track using ACE. Steve has nearly ten years of experience with ACE, and more than twenty years of software development experience, focusing on network protocol and C++ networked application development in a wide range of hardware and software environments.

0201699710AB06232003

Illustrations

xi

Tables

xiii

Foreword

xv

Preface

xix

Part I: ACE Basics

1

(120)

Introduction to ACE

3

(22)

A History of ACE

3

(2)

ACE's Benefits

5

(1)

ACE's Organization

6

(1)

Patterns, Class Libraries, and Frameworks

7

(1)

Porting Your Code to Multiple Operating Systems

8

(3)

Smoothing the Differences among C++ Compilers

11

(8)

Using Both Narrow and Wide Characters

19

(2)

Where to Find More Information and Support

21

(2)

Summary

23

(2)

How to Build and Use ACE in Your Programs

25

(12)

A Note about ACE Versions

25

(1)

Guide to the ACE Distribution

26

(1)

How to Build ACE

27

(3)

How to Include ACE in Your Applications

30

(1)

How to Build Your Applications

31

(5)

Summary

36

(1)

Using the ACE Logging Facility

37

(40)

Basic Logging and Tracing

38

(5)

Enabling and Disabling Logging Severities

43

(4)

Customizing the ACE Logging Macros

47

(8)

Redirecting Logging Output

55

(5)

Using Callbacks

60

(4)

The Logging Client and Server Daemons

64

(6)

The LogManager Class

70

(3)

Runtime Configuration with the ACE Logging Strategy

73

(2)

Summary

75

(2)

Collecting Runtime Information

77

(10)

Command Line Arguments and ACE_Get_Opt

78

(5)

Accessing Configuration Information

83

(2)

Building Argument Vectors

85

(1)

Summary

86

(1)

ACE Containers

87

(34)

Container Concepts

88

(2)

Sequence Containers

90

(13)

Associative Containers

103

(12)

Allocators

115

(4)

Summary

119

(2)

Part II: Interprocess Communication

121

(96)

Basic TCP/IP Socket Use

123

(18)

A Simple Client

124

(5)

Adding Robustness to a Client

129

(6)

Building a Server

135

(5)

Summary

140

(1)

Handling Events and Multiple I/O Streams

141

(46)

Overview of the Reactor Framework

142

(1)

Handling Multiple I/O Sources

142

(13)

Signals

155

(3)

Notifications

158

(2)

Timers

160

(8)

Using the Acceptor-Connector Framework

168

(13)

Reactor Implementations

181

(4)

Summary

185

(2)

Asynchronous I/O and the ACE Proactor Framework

187

(20)

Why Use Asynchronous I/O?

188

(1)

How to Send and Receive Data

189

(8)

Establishing Connections

197

(4)

The ACE_Proactor Completion Demultiplexer

201

(1)

Using Timers

202

(1)

Other I/O Factory Classes

202

(1)

Combining the Reactor and Proactor Frameworks

203

(2)

Summary

205

(2)

Other IPC Types

207

(10)

Interhost IPC with UDP/IP

207

(6)

Intrahost Communication

213

(2)

Summary

215

(2)

Part III: Process and Thread Management

217

(130)

Process Management

219

(16)

Spawning a New Process

219

(7)

Using the ACE_Process_Manager

226

(5)

Synchronization Using ACE_Process_Mutex

231

(3)

Summary

234

(1)

Signals

235

(14)

Using Wrappers

236

(3)

Event Handlers

239

(7)

Guarding Critical Sections

246

(1)

Signal Management with the Reactor

247

(1)

Summary

248

(1)

Basic Multithreaded Programming

249

(18)

Getting Started

250

(1)

Basic Thread Safety

251

(6)

Intertask Communication

257

(9)

Summary

266

(1)

Thread Management

267

(22)

Types of Threads

267

(4)

Priorities and Scheduling Classes

271

(4)

Thread Pools

275

(1)

Thread Management Using ACE_Thread_Manager

276

(3)

Signals

279

(4)

Thread Start-Up Hooks

283

(1)

Cancellation

284

(4)

Summary

288

(1)

Thread Safety and Synchronization

289

(24)

Protection Primitives

289

(12)

Thread Synchronization

301

(8)

Thread-Specific Storage

309

(2)

Summary

311

(2)

Active Objects

313

(12)

The Pattern

314

(2)

Using the Pattern

316

(8)

Summary

324

(1)

Thread Pools

325

(22)

Understanding Thread Pools

325

(1)

Half-Sync/Half-Async Model

326

(12)

Leader/Followers Model

338

(5)

Thread Pools and the Reactor

343

(3)

Summary

346

(1)

Part IV: Advanced ACE

347

(132)

Shared Memory

349

(28)

ACE_Malloc and ACE_Allocator

350

(2)

Persistence with ACE_Malloc

352

(4)

Position-Independent Allocation

356

(3)

ACE_Malloc for Containers

359

(15)

Wrappers

374

(2)

Summary

376

(1)

ACE Streams Framework

377

(42)

Overview

377

(1)

Using a One-Way Stream

378

(19)

A Bidirectional Stream

397

(20)

Summary

417

(2)

ACE Service Configurator Framework

419

(18)

Overview

420

(1)

Configuring Static Services

420

(7)

Setting Up Dynamic Services

427

(3)

Setting Up Streams

430

(1)

Reconfiguring Services During Execution

431

(2)

Using XML to Configure Services and Streams

433

(1)

Configuring Services without svc.conf

434

(1)

Singletons and Services

434

(1)

Summary

435

(2)

Timers

437

(20)

Timer Concepts

437

(2)

Timer Queues

439

(8)

Prebuilt Dispatchers

447

(3)

Managing Event Handlers

450

(5)

Summary

455

(2)

ACE Naming Service

457

(22)

The ACE_Naming_Context

457

(2)

A Single-Process Naming Context: Proc_Local

459

(9)

Sharing a Naming Context on One Node: Node_Local

468

(8)

Sharing a Naming Context across the Network: Net_Local

476

(2)

Summary

478

(1)

Bibliography

479

(2)

Index

481

What is included with this book?

The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any access cards, study guides, lab manuals, CDs, etc.

The Used, Rental and eBook copies of this book are not guaranteed to include any supplemental materials. Typically, only the book itself is included. This is true even if the title states it includes any access cards, study guides, lab manuals, CDs, etc.

ACE (the ADAPTIVE Communication Environment) is a powerful C++ toolkit that helps you develop portable, high-performance applications, especially networked and/or multithreaded applications, more easily and more quickly with more flexibility and fewer errors. And, because of ACE's design and frameworks, you can do all this with much less code than with other development approaches. We've been using ACE for years and have found it exceedingly helpful and well worth any price. What's better is that it's available for free! The historical price many developers have paid to use ACE is a steep learning curve. It's a big toolkit with a large set of capabilities. Until recently, the best documentation has been the source code, which is, of course, freely available, and a set of academic papers born of the research that produced ACE, approachable only by advanced professionals and upper-level students. This barrier to learning has kept ACE's power and easy-to-use elegance one of the best-kept secrets in software development. That's why we're very excited to write this book! It flattens out ACE's learning curve, bringing ACE's power, elegance, and capabilities to all. This book teaches you about ACE: a bit of its history and approach to development, how it's organized, how to begin using it, and also how to use some of its more advanced capabilities. We teach you how to do things the ACE way in this book, but we could not possibly fit in a complete reference. Use this book to get started with ACE and to begin using it in your work. If you've been using ACE for a while, there are probably descriptions of some capabilities you haven't seen before, so the book is useful for experienced ACE users as well. Who Should Read This Book This book is meant to serve as both an introductory guide for ACE beginners and a quickly accessible review for experienced ACE users. If you are an ACE beginner, we recommend starting at the beginning and proceeding through the chapters in order. If you are experienced and know what you want to read about, you can quickly find that part of the book and do not need to read the previous sections. This book is written for C++ programmers who have been exposed to some of the more advanced C++ features, such as virtual inheritance and class templates. You should also have been exposed to basic operating system facilities you plan to use in your work. For example, if you plan to write programs that use TCP/IP sockets, you should at least be familiar with the general way sockets are created, connections are established, and data is transferred. This book is also an excellent source of material for those who teach others: in either a commercial or an academic setting. ACE is an excellent example of how to design object-oriented software and use C++ to design and write high-performance, easily maintained software systems. Organization This book is a hands-on, how-to guide to using ACE effectively. The many source code examples illustrate proper use of the pieces of ACE being described. The source code examples are kept fairly short and to the point. Sometimes, the example source is abridged in order to focus attention on a topic. The complete source code to all examples is on the included CD-ROM and is also available on Riverace Corporation's web site. The included CD-ROM also includes a copy of ACE's source kit, installable versions of ACE prebuilt for a number of popular platforms, and complete reference documentation for all the classes in ACE. The book begins with basic areas of functionality that many ACE users need and then proceeds to build on the foundations, describing the higher-level features that abstract behavior out into powerful patterns. Part I introduces ACE and provides some generally useful information about the facilities ACE provides. Part I also explains how to configure and build ACE, as well as how to build your applications that use ACE