Systems<ToolKit>ä Case Study
Industry: Telecommunications
Company: SYSNETICS and AT&T
Project: High-speed Call Transaction Processor
Requirements
In 1995, AT&T embarked on a project to develop a high-speed call transaction processor for use with an internal billing system. Because this was the first object-oriented C++ project for many of the AT&T development team, AT&T enlisted the help of SYSNETICS, based in St. Petersburg, FL, to aid in this effort.
Led by Fred Hebbel, SYSNETICS would provide both analysis and design support, as well as mentoring, to the AT&T development team, with the constraint that mentors were not to code any portion of the final system. Besides this challenge of technology transfer to the AT&T team, Fred’s team faced many challenges in completing this project.
The team was to build a system that could handle transaction rates in excess of 20,000 calls per second. Each call required multiple tabular calculations using business data parameterized by each unique AT&T customer. High speed, multi-threaded, memory-efficient object containers were required to meet this transaction rate requirement. Hebbel Consulting and AT&T started looking for an implementation of the ANSI/ISO Standard Template Library to satisfy this need.
The target platform for the production system was Sun Solaris. However, because Fred and his staff traveled extensively, they created their educational examples on laptops using Windows NT. The AT&T developers used these examples to learn the techniques to use in developing production code on Solaris. To minimize any confusion caused by this multi-platform environment, a portable source solution was required.
To optimize the throughput of the transaction processor, the AT&T development staff would have to use the powerful multi-threaded facilities of their operating system. This meant a suite of thread synchronization constructs were required to allow the production system to protect shared data from corruption by multiple concurrent threads of execution. Fred and his staff quickly learned that the operating system interfaces to threads and synchronization are not portable, nor intuitive. Learning C++ and good object oriented programming techniques is hard enough without introducing different operating system interfaces. Hebbel required a portable, object oriented interface to threads and thread synchronization to minimize the affect of this additional complexity.
In summary, the critical factors were:
- High performance, memory efficient containers
- Source portability between Windows and Sun Solaris
- Easy to use, portable thread programming and synchronization interfaces
"We wanted a development tool from a company that was leading the pack with Standards. Because we needed to create both a production environment and a different instructor’s environment, portability across multiple platforms became extremely important. It was equally important that the development tool came from a commercial vendor so support would be available if needed," said Hebbel.
ObjectSpace Role
ObjectSpace, a leader in advanced software technology, ensures successful creation and deployment of advanced technology solutions for business problems. Its C++ Component Series leads the market in providing portable class libraries with a full set of features ranging from a portable implementation of the C++ Standard Library to libraries for systems programming and Web development.
Initially, Hebbel looked at tools from vendors like Rogue Wave but felt they were behind the industry with regards to standards. When they came across an advertisement for Systems<ToolKit>™ from ObjectSpace, Inc., they found the solution to their problem.
"Adoption of the standard was important to us. It protects the investment in code and staff training unlike the use of costly proprietary libraries. ObjectSpace is obviously leading the pack in standards adoption," said Fred Hebbel. After evaluating Systems<ToolKit>, Hebbel said, "Here is the answer to our problem."
Fred and his group used Systems<ToolKit> to create training examples with Borland 4.5 under Windows NT and production implementations under Sun Solaris. Initially, they were only going to use it for high performance standard containers, but Hebbel and his staff found many more valuable features like threading and synchronization, plus international time and date facilities.
Hebbel was impressed with the code and said, "When you get right down to it, the code was so straight forward it was incredible."
Architecture
The development staff had to design a system that could process every long distance call made in the United States by an AT&T customer. With over 70 million customers making up to 20 thousand calls per second, the transaction rates were staggering. Each call required a tabular lookup of business data for use in completing the transaction.
To meet this requirement, they designed the system to keep the tabular data resident in physical memory (3 Gbytes) at all times. This allows a memory lookup with speeds that can match the transaction rates required. The design contains a matrix of maps implemented using the ANSI/ISO Standard Template Library from the ObjectSpace Systems<ToolKit> product. The matrix, implemented as a vector of vectors, is indexed on area code and exchange, pointing to a map of customers in that exchange. The total structure contains 70 million memory resident fine grained objects at runtime.
Because the transaction processor required interfaces to legacy systems, there were portions of a transaction processing that had latency. To keep the throughput of the system high while allowing for the legacy system access latency, the developers adopted a multi-threaded architecture. AT&T engineers were trained in multi-threaded programming techniques using the Systems<ToolKit> thread and synchronization abstractions. They used these same abstractions to develop thread-safe transaction queues. These queues are used by multiple concurrent threads of execution to allow several transactions to be processed at the same time. This approach minimizes the effects of latency due to legacy system access.
Conclusion
In many complex systems today, there exist two often conflicting design forces: portability and performance. The use of Systems<ToolKit> provides portability for critical features like containers and multi-threading. But, as Fred Hebbel says, "The key is that the performance did not degrade significantly."
This is due to several factors.
First, Systems<ToolKit> uses, extends, and adopts the ANSI/ISO Standard Template Library. This means its containers are faster and use less memory than almost any other container implementation available today.
Secondly, the Systems<ToolKit> operating system interfaces are thin, and use native APIs whenever possible, resulting in minimal performance degradation as a result of the increased portability and usability.
Systems<ToolKit> provided Hebbel Consulting, Inc. the tools it needed to train AT&T developers in the concepts, without dealing with complexity of portability. Because Systems<ToolKit> is also efficient, high-performing, and cost effective, AT&T demonstrates an implementation that processes up to 20 thousand calls per second.
Contact ObjectSpace, Inc., today for a Systems<ToolKit> technical overview at (972) 934-2496 or visit www.objectspace.com.
For more information about SYSNETICS call (813) 398-6099 or visit www.sysnetics.com.
Home | About Us | Services | Training | Opportunities | White Papers | Contacts | Links
© 1998 SYSNETICS, Incorporated. All rights reserved. webmaster@sysnetics.com