catch menory

what is ment by catch memory how to set a service in catch memory ?

are you referring to cache memory???


Be very, very careful when caching a service. The entire pipeline is saved, not just the inputs/outputs of the service. This can have impact on memory usage and on integration behavior.

When invoking a service that is cached, I recommend calling as a transform or within a scope to limit pipeline visibility by the cached service.

Are you talking about Service caching?
If yes then U can do it through following steps :

  1. In the Runtime category of the Properties panel for the service, set Cache results to True.
  2. In the Cache expire field, type an integer representing the length of time (in minutes) that you want the results for this service to be available in cache.

When you enable caching for a service, webMethods Integration Server saves the entire contents of the pipeline after invoking the service in a local cache(Main memory) for the period of time that you specify. In the subsequent calls to the same service, it will match the inputs with the inputs in the cache and if it matches it returns the cached result, otherwise IS will re invoke the service and return the result.


caching services generally means you are doing something in webMethods IS that you shouldn’t.:eek:

I think there are scenarios when caching is a good thing. But it indeed must be used judicuously.

after reading this topic I hesitated between creating another, but I think it may be relevant to this topic so anyway:
When you say that it saved the entire pipeline and not only the input/outputs, does that mean that if a lot of services call the cached service with an entirely different pipeline except for the inputs, the IS will keep a record of all the pipelines?
We have a service which basically launches an SQL request, which should always return the same output during the IS runtime (depending on the input of course), so we cached this service, which is launched within hundreds of different other services (with hundreds of different pipelines of course). Is this a memory eater?

I’m not sure what IS uses as the key for the cached data–it may use data from just the input fields or it may use everything from the pipeline.


What is also something to be wary of is that the cached service will restore all the variables to the pipeline from the cache. The means if var foo had ABC in it at cache time, and some other service also uses foo which is set to XYZ when the cached service is called, then the resulting pipeline upon return will have foo set to ABC–which can be disastrous for the integration. (This issue bit me a couple months back and took me a bit of time to debug!)

Here are a few ways in which to call cached services safely:

  • As a transformer. This limits the scope of the pipeline for caching.
  • Call the service specifying a scope–same impact, just different config/usage.
  • Wrap the cached service with a non-cached service. For example, serviceX accepts A, B, C and returns X, Y, Z. Not cached. It does one thing–calls (as a transformer or via scoped invoke) serviceX_cached which has the same inputs and outputs and is cached.

The 3rd approach has the advantage of not requiring anything special by the callers–just call the service as they would anything else.

Hope this helps.

To avoid problems with cached services use “clearpipeline” at the end of you cached service and put all your outputs.