As we discussed last month, performance is often an afterthought when building new systems, including SOAs. We're finding that services and SOAs fall victim to this oversight as well. Indeed, there is a right way and a wrong way to design a service and an SOA. Also, there are things that are out of your control that you must consider during your design.

This month let's continue our discussion with some important performance concepts, including how to create a performance model, as well as more service and SOA design tips when considering performance.

Creation of a Performance Model
SOAs are not unlike any other distributed computing systems, and thus designing a performance model should be nothing too new. At this point we understand exactly how each service behaves under an increasing load, and we have enough data to plug into a model. Now, it's just a matter of building a model.

There are very expensive performance monitoring and simulation tools that are for sale in the market, but sometimes the least expensive and most simple tools work best...in many cases, just a spreadsheet will do. For our purposes, we need to consider both information and behavior in the context of performance, as well as core features of an SOA.

Information Movement Modeling, typically asynchronous in nature, means we're attempting to simulate how information moves from point to point, point to many points, or many points to many points. Based on the information we accumulated we know the:

• Information production rate from a service
• Information consumption rate from a service

Moreover, keep in mind transformation and routing latency is typically an issue here as well, and needs to be modeled along with consumption and production. You should have test data from these services, but the performance of transformation and routing services will be largely dependent upon the complexities of the transformations and logic associated with the routing. What many do when creating performance models is to model very complex, complex, and simple transformation scenarios, and the percentages of each.

Service Invocation Modeling, typically more synchronous in nature, means we're attempting to determine the number of times a service is able to provide a behavior (application function) in an instance of time, typically a second.

For instance, you may have a service that provides a risk calculation for the insurance business, and is perhaps abstracted into several different applications (composites). We know through testing that each composite can invoke the service up to 100 times a second before it hits a saturation point, meaning the performance of the service quickly diminishes as additional load is placed upon it. This saturation number plugs into the model, as well as the number of applications that are abstracting this service. You have to model all of these services in the same way.

Models are important because they allow you to predict performance under changing needs without having to actually build and test the system. Models, of course, are not perfect, and you must constantly adjust assumptions and modeling information as you learn more about the behavior of the architecture.

Designing for Performance, Monitoring, and Optimizing
So, now that we know how to diagnose the performance of an SOA, as well as model for it to determine how it will behave in a changing environment, how do we design a service and SOA with optimized performance? Here are a few tips.

• The more processing you can place at the origin of the service, the better your SOA will perform. In many SOAs, the architects abstract the services to a single server, and performance can be somewhat problematic in larger implementations.
• Many services are built on top of more traditional legacy APIs, and as such the translations between legacy APIs to expose them as services may cause performance problems. The ability to leverage existing legacy systems as services is a powerful notion. However, you must be careful in selecting the proper enabling technology to do this. Service invocations that take a second or more to produce behavior, or information bound to behavior, will cause big problems when you align them with hundreds of other services that are doing the same thing.
• The use of too many fine-grained services may cause performance problems. Indeed, you should not be afraid to leverage fine-grained services within your SOA. However, you need to understand the performance issues associated with doing so, and take the network bandwidth and how other applications leverage the services into careful consideration.
• Make sure to consider performance when selecting your orchestration layer. Many BPEL engines are notoriously poor performers, and can become the bottleneck for the SOA.
• Understand the basic rule that, while the value of an SOA is the ability to leverage many remote services, the more services you leverage, the more problematic your SOA will become.

What is more, many SOA technology vendors have not focused on scalability within their solutions. Instead, feature/function enhancements are the rule of the day. Architects feel it's more important to add orchestration features and more adapters to their solution than to figure out how to reliably pump more information, and manage more services, with their product. It's time for that focus to change.