SAP Policy Management 5.4

Transcription

1 Performance Guide SAP Policy Management Document Version: CUSTOMER Performance Guide

2 Typographic Conventions Type Style Example Description Words or characters quoted from the screen. These include field names, screen titles, pushbuttons labels, menu names, menu paths, and menu options. Textual cross-references to other documents. Example EXAMPLE Emphasized words or expressions. Technical names of system objects. These include report names, program names, transaction codes, table names, and key concepts of a programming language when they are surrounded by body text, for example, SELECT and INCLUDE. Example Output on the screen. This includes file and directory names and their paths, messages, names of variables and parameters, source text, and names of installation, upgrade and database tools. Example Exact user entry. These are words or characters that you enter in the system exactly as they appear in the documentation. <Example> Variable user entry. Angle brackets indicate that you replace these words and characters with appropriate entries to make entries in the system. EXAM PLE Keys on the keyboard, for example, F2 or E NTE R. CUSTOMER 2017 SAP SE or an SAP affiliate company. All rights reserved. Typographic Conventions

3 Document History Version Date Change First version of this guide for release 5.4 Document History CUSTOMER Document History 3

4 Table of Contents 1 Introduction Disclaimer About this Document Business Context Involved Components Composite Notes for Performance Basics: Sizing, Hardware, Settings, and Tools Sizing Initial Sizing Re-Sizing Virtualization FS-PM Settings Parameter Recommendation Adjust Number Interval Buffers for Number Range Objects Optimize Serialization Runtime for Product Engine Minimize Transient Attribute Transfer between FS-PM and FS-ICM Restrict Loading of Reversed Contracts Deactivate Dependencies between Contracts Activate Correspondence Cache Deactivate Authorization Checks for Sales Products Optimizing System Performance for FS-PM General Measures Time Model Use Asynchronous Interfaces / Buffer Data from Other System Needed for Update Run Improving Dialog Interaction Table of Contents CUSTOMER Table of Contents 4

5 3.2.1 Enhanced Business Transaction Sequences Directly Choose the Business Transaction and Execution Level on the Entry Screen of Business Process Change Accelerate Changes of Insurance Policies Initiated from Policy and Contract Summary Target Date for Update Run Multi-Contract Processing Improving Batch Processing Update Policies/Contracts FS-PM Performance Measurement and Analysis Performance Measurement Data Preparation Introduction Tools to Generate Test Data Introduction to Performance Tools Business Transaction Analysis (STAD) Performance Trace (ST05) SQL Monitor (SQLM) Single Transaction Analysis (ST12) Performance Analysis (SAT) Memory Snapshot Analysis (SMI Memory Inspector) Enterprise Service Performance (SoapUI) Code Inspector (SCI) FS-PM-Specific Debugging Useful Breakpoint Debugger Script (SAS) Typical Use Case Study Identifying Database Issues Analyzing Internal Tables Memory Runtime Type Creation Redundant Logic Table of Contents CUSTOMER Table of Contents 5

6 5 Integration of FS-PM with Other Systems FS-PM Architecture API Communication Accessing Policy Data via Remote Function Call Enterprise Services Decoupled Components Business Partner (FS-BP) Collections & Disbursements (FS-CD) Claims Management (FS-CM) Incentive and Commission Management (FS-ICM) Loans Management (FS-CML) Reinsurance (FS-RI) Financials (FI) Organizational Management (PD-Org) Portfolio Assignment (PFO) Correspondence Business Intelligence (BI) Product and Quotation Management (FS-PQM) Product Engine Appendix Example of Application Interface Enterprise Service Performance Tracing Background for Initial Load Preparation Measurement Troubleshooting FS-PM Sizing Questionnaire Table of Contents CUSTOMER Table of Contents 6

7 1 Introduction 1.1 Disclaimer This guide is not part of SAP product documentation. By using this guide, you agree that (unless expressly stated otherwise in your agreements with SAP) you may not infer any product claims against SAP based on this information. 1.2 About this Document This performance guide presents tools, guides and best practices on how Policy Management (FS-PM) can be used in a performant way. The target audiences of this guide include IT managers, system administrators, consultants, partners, business analysts, and developers. This guide focuses on FS-PM and the interfaces with other systems. Standard SAP system settings are only described where necessary. For general information on product performance, please refer to Business Context SAP Policy Management (FS-PM) allows you to manage insurance contracts. It is possible to map the whole life cycle of a contract, starting from the creation of an application, through policy issuance and ongoing contract maintenance, right up to the termination of the contract. The following business processes are available: New Business Central Access Inquiry Change Universal Change Reversal Reset Mass Change 7

8 With various business transactions, you can execute scheduled and unscheduled (irregular) processing activities on contracts. Examples of scheduled processing activities are premium debit entries, adjustments, correspondence, and contract extensions. Examples of unscheduled (irregular) processing activities are changes to the sum insured or to the payment frequency. 1.4 Involved Components SAP Policy Management is a central component in the solution portfolio SAP for Insurance and it is based on SAP NetWeaver. It is an integral part of all business processes. FS-PM exchanges information with these components. SAP Policy Management has numerous interfaces with other components, such as: Business Partner (FS-BP) Collections and Disbursements (FS-CD) Claims Management (FS-CM) Incentive and Commission Management (FS-ICM) and Portfolio Assignment (PFO) Reinsurance (FS-RI) Financial Accounting (FI) Organizational Management (PD-Org) Business Intelligence (BI) Product engines such as msg.pm and FS-PRO Product and Quotation Management (FS-QUO) Its architecture allows FS-PM to be connected to other systems as well without modification. Create new business Periodic upate Information R Change / universal Change Reset Reverse FS-PM R FS-CD Collection Disbursements FI R R FS-CM Claims Handling R FS-ICM Commissions FPO R R FS-RI Reinsurance R Business Partner Calculate Import data R Msg.pm Calculate Import data R FS-PRO/ FS_PWS R FS-QUO Create new business Find Policy Retrieve Policy PM data FS-CD data FI data FS-CM data FS-ICM data FPO data FS-RI data BP data Msg.pm data FS-PRO data FS-QUO data Figure 1: Integration Between FS-PM and Other SAP Insurance components 8

9 Currently, most communication is done via asynchronous BAPIs and Remote Function Calls (RFCs), such as for New Business, Insurance Object Handling, Migration, and so on. Among all the components above, the integration of FS-PM and the product engine plays a key role with regard to performance. This is because new versions of insurance contacts and applications are calculated with the help of the product engine. For more recommendations about the integration of FS- PM and the product engine, please refer to Section Composite Notes for Performance Listed below are the composite SAP Notes relevant to performance for SAP Policy Management and SAP Policy Management Auto, respectively: SAP Note number Policy Management * - Composite SAP Note on Performance in Policy Management Policy Management Auto * - Composite SAP Note for performance in FS-PM Auto * SAP Notes and are being continually updated by adding new performance-related SAP Notes. 9

10 2 Basics: Sizing, Hardware, Settings, and Tools 2.1 Sizing Sizing means translating requirements from different business applications to hardware requirements. Hardware costs are dominated by the following major performance key indicators: CPU, memory, disk and the front-end network load. A thorough description of the general sizing procedure for SAP systems can be found, for example, in Sizing SAP Systems: SAP PRESS Essentials 27 Paperback written by Susanne Janssen (Author) and Ulrich Marquard (Author). For the discussion of sizing an FS-PM system, it is important to consider the peak load of a system. We need to consider both dialog and batch processes. In FS-PM, the peak load is often caused by the update run. So, it is important to understand the resource consumption of the update run in detail. Typically, this high-load peak occurs only once a month, and the utilization of the hardware is quite low during the rest of the time Initial Sizing Sizing is done for the first time by a method called "initial sizing". The initial sizing is helpful for the first projection when you have little knowledge about the scope and the usage of the solution. This sizing approach makes many assumptions about the usage and the set-up of business processes. For initial sizing, SAP Policy Management offers an Advanced Sizing - SAP Policy Management Sizing Questionnaire asking for details about policy numbers, constraints for updates and user interaction to give a first rough idea for the required hardware. Please see Appendix 6.3 for details. You can fill in the questionnaire and send it to SAP for a rough estimation of the resource consumption of the update run and dialog process. We strongly recommend you to tailor your processes as early as possible based on this sizing information to match the specific customer requirements as well as possible, and to measure system performance to be able to estimate the requirements for system sizing. For initial sizing for coupled components (SAP FS-PM Auto and msg.pm), please create a customer message. 10

11 The result of the sizing includes the numbers for the following server requirements: SAPS Application Server SAPS Database Server Data Volume (TB) What is SAPS? SAP Application Performance Standard (SAPS) is a hardware-independent measurement unit which describes the throughput of hardware in an SAP environment. 100 SAPS equals 2,000 fully processed order line items per hour Re-Sizing Continue and repeat the sizing efforts every time a new development/implementation milestone is reached. As the resource consumption of each process depends heavily on the customized attributes and implementation of a policy, the initial sizing can only be an estimation. Therefore, it is important to redo the sizing as soon as the real resource consumption can be measured. As soon as the customer-specific implementation is testable, you can redo the sizing by measuring the resource consumption of different resources in the test system and linear extrapolation to the expected business volumes needed for production. It is very important, at this stage, not to only measure the resource consumption of the update run, but to also make some measurements of other important business processes. It is necessary to verify the assumption that their resource consumption is small enough to be neglected for sizing, as originally assumed. And, of course, to identify potential performance issues with these processes. In other cases, such as increased workload or an additional line of business, re-sizing is also necessary Virtualization For systems that are sized for a rather high peak to average load, we recommend to consider virtualization as an option to provide sufficient resources during the peak time, and to be able to make use of the resources at off peak times. This can either be done by considering the load of non-productive systems like DEV (development), QA (quality assurance) and PreProd (preproduction), or by considering other productive systems if a mix of production and non-production system is not wanted. Applying this to FS-PM, this means that the resources needed to run the update run do not need to be available for FS- 11

12 PM for the rest of the time. Virtualization might help to reduce the overall resource consumption considerably in this situation. 2.2 FS-PM Settings Parameter Recommendation To ensure that the system runs smoothly and efficiently, we recommend you to adjust the following parameters. Parameters Description Current Value abap/buffersize Size of program buffer zcsa/table_buffer_area Size of generic key table buffer zcsa/db_max_buftab Max. number of buffered objects Run transaction RZ10 to maintain SAP profile parameters. Note You may see warnings and error messages. Ignore those messages and implement the recommendations provided in the above table. They are carefully checked by service consultants and overrule the standard checks provided by RZ Run the program SAPPFPAR (see SAP Note ) before you start the SAP instance with the new parameter settings. If any errors occur, save the output file and contact your Service Center for advice. Restore the old parameter settings and restart the SAP instance Adjust Number Interval Buffers for Number Range Objects In SAP Policy Management, there are several number range objects. Each number range object is defined by whether buffering is allowed and how many numbers are in the interval buffer. For FS-PM 5.3 SP02 and later releases, number ranges objects that allow buffering and have a high demand are set to 500 in the interval buffer. Number range objects with an intermediate demand are set to 50, number range objects with a low demand are set to

13 Note Number range buffering is not allowed for the following number range objects: /PM0/ABN49, /PM0/ABN50, /PM0/ABN51, and /PM0/ABN52. The number interval buffer is in the shared memory of the application server. Each buffer is used to store the external number intervals and a certain number (sub-interval) of the internal number intervals. If the numbers of an internal number interval are used up, numbers are taken from the database via the number range server. When buffering number intervals, gaps may occur in number assignment, for example when the application server is shut down and the numbers in the buffer of the application server are lost. Therefore, buffering is not possible for applications that require continuous number assignment (e.g. /PM0/ABN51). When there are performance issues with the interval buffer of a number range object, the SQL trace will show high access to table NRIV and the related number range object, especially when you are dealing with multiple parallel jobs (e.g. in the update run). Recommendation If you recognize performance issues due to the set of numbers in the interval buffer being too small, you may adjust the setting via modification in the number range object. In addition, please report to SAP that there is a potential performance issue because of the current settings of the numbers in the interval buffer of a number range object. Do not change the settings for number ranges where buffering is NOT allowed Optimize Serialization Runtime for Product Engine To serialize the data for the product engine more quickly, you can generate class ZCL_ALH_PM_CALCULATION_GEN with the Customizing activity Policy Management -> Integration -> Product Engine -> Connection with msg.pm -> Optimize Serialization Runtime. This considerably improves the runtime of all calls of the product engine in the Life line of business since the call is no longer generic, but rather the fields used in the customer implementation are generated into the class. You execute this Customizing activity after you have filled the reference model tables, or when the reference model is enhanced or changed. Please refer to the documentation of the Customizing activity for more information. 13

14 2.2.4 Minimize Transient Attribute Transfer between FS-PM and FS-ICM To improve the communication performance between the FS-PM and FS-ICM systems, the transient attribute transfers should be minimized. In the Customizing activity Policy Management -> Integration -> Incentive and Commission Management FS-ICM->Process FS-PM Entities/Attributes Relevant to FS- ICM, you define which attributes of the different entities of an FS-PM policy are transferred to the transfer structures of Incentive and Commission Management in a commission case (attribute mapping). You also define which FS-PM entity is mapped to which ICM structure in the dialog structure ICM-Relevant Entities. During the transfer process, a check has been built in class /PM0/CL_AB_INT_CS to search for transient fields with initial value among the fields to be transferred to FS-ICM. If any transient fields are detected, the transient derivations are performed to determine the transient field value. Therefore, from a performance point of view, it is possible to avoid transient derivation for unnecessary fields. We recommend checking the implemented Customizing activity and excluding unused transient fields being transferred to FS-ICM. For more information, please refer to the documentation of the Customizing activity. The sample Customizing delivered for this activity contains several transient fields that have been introduced mainly for demonstration purposes. Please check whether your implementation makes use of these fields, otherwise they can be removed Restrict Loading of Reversed Contracts To speed up the loading of policies with a large number of reversed contracts, you can make Customizing settings such that the system only loads active contracts and contracts with a reversal date after a specific date. The loading restriction is defined in Customizing for SAP Policy Management. Choose Policy Management -> In-Force Business Management -> Basis -> Business Processes -> General Settings -> Restrict Loading of Reversed Contracts. 14

15 When the Restrict Loading checkbox is selected, as shown above, only the contracts that are reversed within 12 months will be loaded. You can change the number of months. Please note that this date refers to the effective date of a business process, and not to the system date. Note In the initial screen of each business process, the policy handler can overrule the restriction defined in Customizing by selecting the Load All Reversed Contracts checkbox. Example You have a policy with three contracts, two of which have been reversed. One contract was reversed on June 1, 2012, and the other one was reversed on January 1, You have set the Customizing activity Restrict Loading of Reversed Contracts as shown in the figure above. Business Process Inquiry When you start the Inquiry business process, the system loads the active contract and contracts that are reversed within 12 months from the effective date. The effective date of this Inquiry process is June 1,

16 The system displays the active contract and the contract that was reversed on June 1, But as the message at the bottom indicates, the contracts that are reversed before June 1, 2011 will not be loaded. Thus the contract that was reversed on January 1, 2011 is not displayed. Reading Policy Data in Background Mode When you load a policy or application in background processing of the Inquiry business process, you can also restrict the reversed contracts to be loaded. In your implementation, call the class method /pm0/cl_uboi_toolkit=>set_exclude_contract ( ) before loading policies in the background. If this method is called before reading the policy data through a unified business object interface (UBOI), the reversed contracts are not read if their reversal was executed in the past. 16

17 Updating Policies/Contracts In processes that update policies or contracts, you can define whether reversed contracts are loaded or not. When this checkbox is selected, contracts with a reversal date prior to that defined in Customizing are not loaded for the update process Deactivate Dependencies between Contracts For policies using policy processing, you can deactivate the dependencies between contracts (including the dependency plan) without losing the advantages of policy processing itself. You can deactivate the dependencies individually for a policy or a sales product. If the dependency status is set to Dependencies Manually Deactivated the system does the following: It does not allow the use of the dependency plan. It does not check after each change or time model function if there is a potential dependency with another contract within the same policy. It removes the dependency between the time model functions of different contracts. Performance improvement will be achieved for the execution of policy time model functions, both in background processing and dialog mode. Note This feature is available for policies created as of FS-PM 5.3 SP01. 17

18 2.2.7 Activate Correspondence Cache To improve the performance for correspondence creation in background runs, you can activate the correspondence cache in Customizing for Policy Management under Correspondence Management -> Improve Performance of Determination of Application Data by choosing Activate Application Data Cache. The detailed description can be found in SAP Note In this Customizing activity, you can determine whether to activate the application data cache in order to improve the performance for the determination of application data, as long as the restrictions listed in the SAP Note do not apply to you. If the cache is deactivated, the application data is determined at the time of printing. Note that it is not the current dataset with today's data that is used as the basis for the correspondence print, but rather the data is determined on the basis of the data origin. If the cache is activated, the application data is temporarily stored at the time of scheduling, and it is read from the cache at the time of printing. Activating the cache improves system performance because the relevant data is already available in the memory at the time of scheduling, and thus it does not have to be determined again at the time of printing. Times of Execution The cache is created when correspondence is scheduled for time model functions and business transactions in Framework for Parallel Processing (FPP) runs. No cache is created for the scheduling of correspondence in dialog mode. Restrictions of Cache Activation Performance can be improved by restricting some of the functions that are not mandatory. 18

19 No transient derivations are performed when the mass business object is used (such as the update run or correspondence run). When the cache is created in these runs, no transient fields are available and consequently they are not taken into account in the creation of the cache. When the cache is activated, the transient derivations are only performed by the transient easy classes which are called in the application form. For background business transactions, only the data origin BTrans Conclusion is supported. You determine the data origin in the Customizing activity Automatically Schedule Correspondence (under Policy Management -> Correspondence Management -> Correspondence Control). Since the non-cash flow documents are determined at the time of scheduling, the offsetting documents and account balances are available in non-consolidated form. Recommendation Only activate the cache if you are not affected by these restrictions. Create test prints with the cache activated and deactivated, and compare the results. For comparison purposes, you can also export XML files using the transaction Display Correspondence Container. Delete the cache data that is no longer required with the transaction Delete Application Data Cache. The cache is optional. Even if the cache is activated, you can delete the cache data at any time without causing data inconsistencies. When the cache is deleted, the application data is determined at the time of printing without the cache. Delete the cache data only when the cache is no longer required for analyzing the cause of errors. Schedule the Delete Application Data Cache program to delete all the cache data that is no longer required that is older than, say, three months. Only use the cache for correspondence types where the performance is critical. You can specify the correspondence types for which a cache is to be created using BAdI: Determination of Application Data. You can access this BAdI in Customizing for Policy Management under Policy Management -> Correspondence Management -> Business Add-Ins (BAdIs). If the importing parameter is IF_CORCACHE_IS_FILLED_FG = abap_true and the BAdI does not return any data, no cache will be created Deactivate Authorization Checks for Sales Products To improve the performance in the search help for sales products, a new Customizing activity Improve Performance of Search Help for Sales Product is now available. In this Customizing activity, by selecting 19

20 the Deactivate Checks checkbox, you can deactivate the following checks in the search help for sales product template IDs on the initial screen of the New Business business process: Authorization check for the sales products Authorization check for mandatory contracts In Customizing for SAP Policy Management, choose Policy Management -> In-Force Business Management -> Basis -> Business Processes -> General Settings -> Improve Performance of Search Help for Sales Product. By default, the Deactivate Checks checkbox is not selected. Note This Customizing activity is only relevant for the search help of sales product templates. When you click the Create button to create an application, all the checks you deactivated will be performed. Example When the Deactivate Checks checkbox is not selected, the system will perform all authorization checks, therefore only two sales product templates for which you have authorization are displayed in the search help window: 20

21 When the Deactivate Checks checkbox is selected, the authorization checks for sales products and mandatory contracts are deactivated, and more sales product templates are displayed: In this case, however, if you select a sales product template for which you do not have authorization, for example _POLHHEX0000 (Sample Household Product Extended), and then click the Create button to create an application, no application will be created and you will receive an error message: 21

22 3 Optimizing System Performance for FS-PM SAP Policy Management uses both dialog and batch mode, so both modes need to be considered in the context of system performance: Overall system performance Performance for dialog interaction Performance for batch scenarios 3.1 General Measures Time Model A central concept of SAP Policy Management is that processes, functions or business transactions that do not need direct user interactions are scheduled and processed in the so-called time model. The time model triggers the following actions: Time model functions: They regularly execute common tasks, such as adjusting the contract s premium based on the contractual agreements with the customer. Business transactions of the Change or Reset business processes for which the input is already known or can be derived by applying special logic. The time model is executed explicitly in Update policies/contracts and implicitly during the start and end phase of the dialog business processes. This section explains how to improve the performance of time model functions Processing Only Required Time Model Functions SAP Policy Management offers the possibility to update policies and contracts in different scenarios. These scenarios are called update types. SAP provides the so-called Standard Update Type that creates new versions of the policy. You can maintain your own update types that do not create new versions but, for example, cash flow documents or insights into future changes of policies and contracts. SAP also provides some examples like the correspondence run or the provisional collection run. 22

23 You can decide which update types are to be executed in Customizing. Recommendation Check and consider the business requirements for all existing update runs, then decide which time model functions have to be executed. You can exclude all other time model functions for your specific update type in the Customizing activity Define Update Types in Customizing for Policy Management under In-Force Business Management -> Basis -> Update -> Define Update Types -> Dates to Be Excluded. Example For an update type such as PCO (Provisional Collection Run), which represents an update that only gives insights into cash flow transactions, it might not be necessary to process time model functions that change fund assignments (AUTOSHIFT) or determine balance sheet values (BVC) Supporting Only Required Interfaces Based on the update scenario (see Section ), it might also not be necessary to interact with all downstream systems or Policy Management s own components. Recommendation Check and consider the business requirements for all existing update runs. Determine for which interfaces interaction is necessary. Determine the required interaction patterns for specific Policy Management components. Maintain the settings in the Customizing activity Define Update Types in Customizing for Policy Management under In-Force Business Management -> Basis -> Update. Example An update type such as PCO (Provisional Collection Run), which only gives insights on the future cash flow transaction, generally does not interact with a commission management system such as ICM, and it does not need the concrete fund prices that are required for determining the cash flow (in case the premium is clearly defined). Therefore, the interaction with the commission management system can be switched off, and only the latest fund price is needed for processing. 23

24 Streamline Your Own Time Model Functions SAP Policy Management provides time model functions to support various processes and use cases. For a specific implementation, some steps may not be necessary, and some interfaces with product engine methods may be too broad. 24

25 Recommendation Check the functionality of SAP Policy Management or customized time model functions and see whether you really need them. Restrict the coding to only execute what is really necessary. In case you do not need specific time model functions, remove their assignment to your product module group. The less coding is executed, the faster the system runs. Example Although the standard framework of time model functions always calls the cash flow component to create cash flow documents (based on Customizing), this might not be the case for specific situations. Therefore, it makes sense to re-implement the respective methods (in this case PROVIDE_COMPONENTS), from a performance perspective Use Asynchronous Interfaces / Buffer Data from Other System Needed for Update Run SAP recommends using only asynchronous interfaces in productive systems. See the Operation Guide of SAP Policy Management on Help Portal. Some customers provide the data needed from other systems in tables before the update run starts to reduce expensive interaction with other systems during the update run. 3.2 Improving Dialog Interaction By reducing the number of interaction steps of the policy handler with the system, the overall processing time can be massively reduced in many cases. In the following sections, we describe some of the options provided by SAP Policy Management to streamline the interaction Enhanced Business Transaction Sequences As of SAP Policy Management 5.3, you can determine the input data for a business transaction that is part of a business transaction sequence by implementing a Business Add-In (BAdI). You can also determine in Customizing if this business transaction is executed by the system, or whether the policy handler needs to confirm the execution. 25

26 The system can also decide not to execute a business transaction in a sequence based on the results of the previous business transactions. Example A policyholder moves from Germany to Austria. This move causes a change in taxation rules, and therefore a premium adjustment is required. The policyholder resides in Germany. As the insurance company is also German, a tax rate of 19% applies. The policy handler starts a business transaction sequence to change the policyholder, makes the system change the settings for tax characteristics, and performs a recalculation. The system asks whether you want to execute Change Tax Characteristics. 26

27 If the premium tax scope already reflects the values to be derived, the system can detect this (using a BAdI), and it skip execution of the business transaction. The system automatically executes the business transactions and recalculates the premium. Example The policy handler starts a business transaction sequence to change the policyholder and automatically derives the new values for taxation. However, the policy handler wants to confirm the changes. 27

28 The system has already derived the input for changing Tax Characteristics. But the data can be reset to the values that were valid before the address was changed. You can define business transaction sequences in the Customizing activity Define Business Transaction Sequences in Customizing for Policy Management under In-Force Business Management -> Basis -> Business Transactions, Actions, and Process Steps. In this Customizing activity, you define whether a business transaction requires user interaction including the possibility of selecting contract elements, and whether input data is prefilled. If you want the system to determine input data, you need to implement the BAdI /PM0/ABP_BTX_CONTROL_SEQ Directly Choose the Business Transaction and Execution Level on the Entry Screen of Business Process Change On the initial screen of the Change business process, you can select the business transactions to be executed on the policy elements. 28

29 As of SAP Policy Management 5.2, it is possible to choose the business transactions and the contract elements for which the business transaction shall be executed on the initial screen of the Change business process. Once you have selected the business transactions and the contract elements, the system directly starts the business transactions on the elements. It is not necessary to choose the contract elements and the business transactions via the navigation tree. For some business transactions, releasing the Change business process also completes these business transactions. So for simple changes to insurance policies, the number of necessary mouse-clicks, the execution time, and the possibility of input errors are significantly reduced. Example Change of Payment Frequency Enter all marked fields on the initial screen, select the contract and business transaction. 29

30 Change the payment frequency and release the change. Example A simplified transaction /PM0/ABC_BTX: Change -> Quick Access. In this simplified transaction, only the necessary input fields are shown. With transaction /PM0/ABC_IBC, on the tab page Bus. Transaction, you can determine which business transactions or sequences are available in the Business Transaction list box on the initial screen. 30

31 3.2.3 Accelerate Changes of Insurance Policies Initiated from Policy and Contract Summary As of SAP Policy Management 5.2, it is possible to directly initiate a change of insurance policy from the Inquiry business process. After analyzing a policy or contract, you can start a business transaction directly in the Change business process by clicking the relevant line. The system starts the Change business process and the customized business transaction for the selected contract element. So for changes to insurance policies, the number of mouse-clicks, the execution time, and the possibility of errors for input are significantly reduced. For example, you can change payment frequency from the Inquiry business process as described below: 31

32 1. Analyze the policy in the Policy Summary. 2. After analyzing, start the Change business process. 32

33 3. Choose the contract you need, then choose the Change Payment Frequency business transaction. 4. Change the payment frequency and complete. 33

34 5. Release the change. In SAP Policy Management 5.2, the following steps are necessary to change the payment frequency of a specified contract after analysis in the Inquiry business process. 1. Enter all marked fields on the initial screen of the Inquiry business process. 2. Analyze the policy in the Policy Summary and initiate the change of payment frequency by double-clicking the payment frequency of the contract. 3. Change the payment frequency and release the Change. 4. The effective date of the Change process is derived from Customizing, and it can be entered from the Policy or Contract Summary. For each element in the Policy Summary, different business transactions or business transaction sequences can be started. The business transactions or sequences can either be started by 34

35 double-clicking the element or by using the context menu. In the context menu, all possible business transactions or sequences for the current line are displayed. The business transaction assigned to the current element in the Policy Summary is highlighted. To define that business transactions can be started from the Policy Summary and Contract Summary, use the Customizing activities Determine Display Structure of Policy Summary and Determine Display Structure of Contract Summary. 35

36 The assigned business transactions for labels can be defined on the second level where the lines are defined. 36

37 The assigned business transactions for each line can be defined on the third level where the fields are defined Target Date for Update Run When the most important dialog processes, such as the New Business, Change, and Reset business process, are released, the updates of policies and contracts are also automatically executed. The target date determines how far in the future from the current effective date the scheduled processing activities are to be executed, and therefore how much time the execution will take. If the target date is far in the future, many time model functions or background business transactions can also be executed in a batch job. Processing such target dates can take a long time. Example A policy starts on 1 January 1, The target date of the update run is set to Always Update Two Years in the Future. In this case, all processing activities from January 1, 2016, to January 1, 2018, are executed when the user releases the new business application. 37

38 Recommendation Try to reduce the time model functions executed upon new application release by setting the target date as close to the current effective date as your business requirements allow. You can define and adapt update types in the Customizing activity Define Update Types in Customizing for SAP Policy Management under In-Force Business Management -> Basis -> Update -> Time Model Multi-Contract Processing Multi-contract processing is a new processing mode that enables the handling of a subset of contracts in a policy. It is the missing link between policy processing and independent contract processing. 38

39 Policy processing always handles the whole policy, whereas contract processing handles changing a single contract without the possibility of changing the policy data. Multi-contract processing mode enables the user to handle a selection of the contracts of a policy and policy data. Therefore, the performance is optimized. This processing mode is available in the Change and Inquiry business processes. For more details about multi-contract processing, see the EKT documents on this subject and check the Composite SAP Note Improving Batch Processing Update Policies/Contracts Introduction The Update Policies/Contracts function (also referred to as the update run ) is used to update contracts for one or more policies up to a target date in mass processing using Framework for Parallel Processing (FPP). By improving the performance of update runs, we can increase throughput in systems, and therefore update as many contracts per minute as possible. The most important input for the update run is the throughput measured for a single process performing the update run and the available timeframe. Using these two values, it is easy to calculate the number of jobs that need to run in parallel to obtain the required throughput. Typically, you should aim for a number of parallel jobs less than 50% of what the system can handle. Using the other simple assumption that a job always consumes the performance of one CPU core at each point of time (which neglects network latency for RFCs and I/O latency on the DB), we have a good number for the overall number of CPUs that need to be available for the update run. These should be distributed amongst the systems that are used by the update run according to the resource consumption measured for the single process. If 5% of the time of the single process is spent on the RFC to the Tomatoes server, 10% on Reinsurance, 20% on SAP ERP, 20% on the SAP Policy Management DB, and 30% on FS-PM application servers, then the number of cores that need to be available for the update run on the corresponding systems can be easily calculated by applying these percentages to the total number of cores calculated from the required degree of parallel processing to get the resources required on each of these systems. Any system that is not capable of providing the required resources will be a bottleneck 39

40 for the update run, forcing the others system to idle. So if the theoretically possible throughput is not attained, in many cases this is not because the SAP Policy Management system is undersized but because there are bottlenecks in the connected systems. The system processes all the due dates for the specified period, except for policy postdating. You use the Business Transaction Scheduler (BTS) to perform policy postdating. The type of update depends on the configuration in Customizing for SAP Policy Management under Force Business Management -> Basis -> Update -> Define Update Types. The update types must not be selected as an internal update type in Customizing General Information on Update Policies/Contracts On the SAP Easy Access screen, choose Policy Management -> In-Force Business Management -> Periodic Processing -> Update Policies/Contracts to update policies/contracts to a target date. The detailed description of this function can be found in Update Policies/Contracts (FPP). Caution On the Technical Settings tab page, the Number of Jobs is the number of work processes running in parallel for an update run. Set the optimum value for jobs to run the update function in parallel for more than one work process at the same time. The Number of Intervals must be specified as it has a vital effect on the update run performance. Package Size on the Restrictions tab page is also an important parameter that could influence the performance behavior. The following sections introduce how to set these parameters to execute the update run under optimum conditions. Select the Restrict Loading of Reversed Contracts checkbox to avoid loading reversed contracts and save the processing time. In the following sections, we describe how to improve the performance of the update runs Interval The Interval Distribution of an Object for Parallel Processing indicates the name of the instance of an object for parallel processing. If the same instance of an object for parallel processing is generated in several processes, only the first instance that is generated can be changed. This is done on the enqueue server. 40

41 Because of the large number of policies in the customer system, it is hard to create the interval distribution manually, so we generally recommend using Dynamic Interval Creation. In addition, if you want to create the interval distribution manually, make sure that the number of intervals is larger than the number of jobs, otherwise the job will work inefficiently. For example, if there are two jobs defined but only one interval, then only one job can be processed at one time during the update run. For detailed information, please see SAP Note Package Size We recommend a package size of about 10. Since the effect of the configured package size depends on the system performance and the objects (contracts) processed in the run, you should test different values to find the best setting. As an option, you can leave the field empty. In this case, the system uses the default value (10). Factors related to package size that affect the throughput include the following: Number of available dialog work processes of the surrounding systems, because RFC communication uses dialog work processes Average response time of RFCs per contract (response time of all RFCs of a package/package size) DB commit time of local server Provide Target Date The target date defines the effective date up until which the future planned changes are to be executed. It is possible to let the system determine the target dates by means of a Customizing activity and BAdI (In-Force Business Management -> Basis -> Update -> Define Update Types). In this case, the target date needs to be determined for every contract, which leads to slower performance. Recommendation Enter the target date or fill it through the external job scheduler to guarantee regular contract updates and to improve system performance. Only leave the field empty when it is really necessary to determine the target date based on single contract input. 41

42 Use Contract-Dependent Update Where Possible The Force Policy Processing checkbox allows the system to update all contracts of a policy. The system automatically determines the processing level for the update. If possible, the system updates the selected policies on a single-contract basis. If this is not possible, the system updates at policy level. In rare cases, the system is unable to determine which processing to use. If this is the case, you must force processing at policy level. In Force Policy Processing mode, potential dependency changes are checked after the execution of each update run, which may result in slower performance. Recommendation Use Force Policy Processing only in case you have potential dependencies between contracts or coverages. Otherwise use Contract Processing. If the Dependency Status is Dependencies Manually Deactivated or No Dependencies Exist, the dependencies between contracts in the update run can be removed when you are using the Policy Processing function. Please refer to Section Processing Similar Objects within One Package/Interval When updating contracts or policies, the time model uses package-wise processing with bundled calls to the product engine, combined reads from the database, and combined calls to the downstream system. It is important to have similar contracts/policies within one package/interval. This will reduce the load on the system in the following ways: Reducing the number of calls of the product engine as much as possible Only loading as little Customizing and set-up data as possible Accessing the minimum number of database tables: If you process packages that have contracts from both the Life and P&C lines of business, it is highly likely that accesses to both Life-specific and P&C-specific tables are required in every package. Bundle the package in a way that only either P&C contracts or Life contracts are in one package, therefore accesses are only required to the database tables for a single LoB. Reducing calls of downstream systems: If there are 10 different downstream systems and 10 different contracts, each of the contracts would have to call one of these downstream systems. Processing this package would cause 10 RFCs, whereas packaging 10 contracts that only need to communicate with one and the same downstream system would result in a single RFC call. Use the selection criteria to have similar objects packaged together: 42

43 If you have complicated contracts or policies that are error-prone and in the past have resulted in unexpected termination of processing (short dumps), the whole intervals might have to be reexecuted, which will in turn increase the overall processing time. The postprocessing of packages with error messages takes more time, as it is sometimes necessary to analyze the messages of the whole package. Recommendation Do not combine error-prone objects that often need postprocessing with simple objects unlikely to cause errors Avoiding Peaks in System Load Updating large numbers of contracts can cause peaks in the system load, which may impact performance. You can avoid these peaks and attain a balanced system load by dividing the contracts into a number of smaller packages and updating each package on a different date. Thus it is not necessary to execute these programs at night when no users are working in the system. This is possible because SAP Policy Management differentiates between the system date and the date a change becomes effective (effective date): A change can be executed before or after the effective date. Example The figure below is an example for this strategy. The time model carries a policy/contract throughout its lifecycle. As long as no important information is missing, this is independent from the real system date. Example 1: Today: November 11 Time model functions for a contract are planned for December 1, December 15, January 1 It is possible to execute all these changes on the current date. So you do not have to wait until December 1 in real time before executing the time model function on December 1. Nevertheless, the changes will be valid only as of the effective date. Even when subsequent changes occur between November 11 and December 1, the system will automatically undo the interim changes to re-execute them after the change. Example 2: Today: November 11 Time model functions for a contract are planned for October 25, November 1, December 1 43

44 It is possible to execute all these changes on the current date. So from a technical view, you do not have to execute time model function before their effective date is reached. Quantity of contracts to be updated Split quantity to several packages Set Threshold for Aborted Jobs in a Batch Run Setting the threshold of aborted jobs for a batch run is a new feature for Update Policies/Contracts or Validate Migrated Policies. When the threshold is reached, the system triggers an ABAP runtime error in running jobs one by one so that all jobs stop running and then the batch run restarts without policies updated in error. For the jobs that are forced to stop, no policies are excluded from the next run. Setting the threshold improves efficiency because a run otherwise restarts only when all the jobs finish running, whether aborted or completed successfully. It might take a long time for waiting to restart even until most of the jobs are aborted. To use the function, you need to do some Developer Customizing change: In Developer Customizing (transaction /PM0/CUST_INT), you have defined exits for the framework of parallel processing (FPP). Choose Internal Customizing -> General Settings -> Define Exits for FPP. In the Customizing activity, assign the FPP exit ABT_THLD and a class/interface to mass activities FP_PA and FP_Q_POL. A sample class /PM0/CL_ABY_FPP_INITRUN_PACK is provided. In the sample class, the threshold value is 50%. You can create a similar class and modify the DEFINE_ABORT_THLD method to set a different threshold value. 44

45 The following SAP Notes are available: Early Restart Dumped FPP Run - Central Change Early Restart Dumped FPP Run - Validate Migrated Policies Early Restart Dumped FPP Run - Update Policies/Contracts Parallel Processing and Throughput In the update run functions of SAP Policy Management, the number of jobs means how many processes are used for updating policies in parallel processing. Generally, the more the jobs are set, the faster the mass policy update can be finished. In practice, it is not possible to set all jobs for updating, because the dialog mode needs jobs for working as well. Furthermore, memory is another factor restricting the job setting, which means too many jobs running in parallel may consume too much memory or cause a system overload. To improve the efficiency of the update runs, it is important to set a suitable number of jobs. Because the total number of jobs in customers systems is different, it is not possible to suggest a default job number. To determine the value that works best in your system, we recommend the following steps: 1. Find out the maximum number of jobs in the target system in the Work Process Monitor. 2. Set the actual job number to half the maximum number of jobs. 3. Set the package size as the default value. 4. Set ParaProcess.Obj to /PM0/CL_ABY_FPP_INT_POLNR_DYN (Dynamic Interval Creation). Table 1 shows the key parameters. No. parallel jobs Package size Interval Half of total jobs Default value (normally 10 in F1 Help) Dynamic Interval Creation Table 1 Table 2 shows the results, including the duration and number of successfully updated policies that are shown directly in update run logs, and TRM and TJM, which can be calculated. Throughput per run per minute (TRM) Number of successfully updated policies TRM = Duration (minute) Throughput per job per minute (TJM) TJM = TRM No. Jobs Table 2 45

46 TRM and TJM are the key indicators that help you decide which number of parallel jobs works best in your system. In general, the bigger the TRM, the less time the update run takes. Example The table below shows an example of testing the best job numbers. The most important elements are Throughput per run per minute, Throughput per job per minute and Memory consumption. Customers can compare the three indicators that are calculated from other parameters (see the formula described in Section ) to decide the best number of jobs of the update run in your systems. Run ID No. of No. of Throughput Throughput No. of Throughput Throughput Memory Average parallel selected per Job per per run per Successfully per job per per run per consumptio Ratio jobs polices minute minute Updated minute minute n (in KB) at Contrac (Selected (Selected Contracts (Successfully (Successful the end of ts per Policies) policies) updated ly updated the jobs*) policy contracts) contracts)) SAP_TEST_01_18_TD ,5 62, ,24 SAP_TEST_01_18_TD ,6 77, ,20 SAP_TEST_01_22_TD _10JOBS ,6 112, ,27 SAP_TEST_01_22_TD _10JOBS ,8 134, , Problem Class of Application Logs In high volume systems, it is better to set the value of Problem Class to 1 or 2 in order to reduce the number of messages reported, in case only error messages are required. 46

47 4 FS-PM Performance Measurement and Analysis This section explains how to use ABAP performance tuning tools to identify performance problems in ABAP programs, database access and memory consumption. ABAP Debugger and ABAP Debugger Script are recommended for further investigation and locating the source of the problem. For more detailed information about performance tools and general use cases, please see Best Practices for ABAP Performance. 4.1 Performance Measurement Data Preparation Introduction Sometimes the system needs to process a certain amount of policies or some specified types of policies. In such cases, it is necessary to measure the system's current processing ability and find the bottleneck. For example, if an FS-PM system needs to process policies with more than 100 contracts (multi-contract processing), the first step is to measure the current system throughput. For these tests, policies with multi-contracts and multi-coverages have to be created. For testing purposes, it is important to create policies with variety and complexity, to get closer to the real business scenario. Although complex policies can be produced with the New Business business process, a lot of manual work is required. And in some business scenarios, policies can only be processed once, while some others require policies with a specific status. Consequently, automated policy generation tools must be deployed Tools to Generate Test Data There are some tools that can be used in FS-PM systems to generate policies automatically or semiautomatically. 47

48 Application Interface You can use the function module /PM0/ABT_APIF_REL_FB. Originally this application interface (APIF) was used to create policies from remote systems such as the CRM component or Web applications. Basically all the policies required can be created with this function module. Detailed information and the individual steps of function module /PM0/ABT_APIF_REL_FB can be found in the Appendix, Example of Application Interface Copy Contract This is another way to create multi-contract, multi-coverage policies. Especially for the scenarios where the contracts and coverages are too complex to be created by the APIF program. With the Copy Contract business transaction, you can create many copies of one contract you have created with just one click. Thus test data for one policy with multiple contracts can be created without any programming effort Test Migration of Policies (/PM0/ABQ_MIGTEST) This program creates migration files for policies existing in SAP Policy Management systems, and it uses these files as a basis for testing your implementation of the technical migration and functional validation in various steps. Here it can be used to generate identical policies created by APIF or with the Copy Contract business transaction. Also, for some specific situations, it might be necessary to provide your own reports to add variety to the created policies. Some demo programs are provided as a guide and reference in the Appendix. To call this report, on the SAP Easy Access screen choose Policy Management -> Migration -> Policies - > Test Migration of Policies or use the transaction /PM0/ABQ_MIGTEST. 48

49 For detailed information, please refer to the Appendix. 4.2 Introduction to Performance Tools The ABAP performance tools can be categorized as: Statistical records display tools: o o STATS STAD ABAP program performance trace and SQL analysis tools: o o o o o SAT ST05 ST12 SQLM SCI Memory management tools: o o ST02 SMI Debugging tools: o o ABAP Debugger Debugger Script (SAS) Enterprise service testing tools: o Soup UI 49

50 4.2.1 Business Transaction Analysis (STAD) STAD is an important tool. Statistical Records is the entry point for the performance analysis. It calculates the resource usage of individual transactions for ABAP systems and provides a detailed analysis of a transaction and the dialog steps. The selection criteria include User, Transaction, Program, Task Type, Start Date, and Start Time. The statistical records contain detailed information about: Proportions of the response time Database accesses Memory use RFCs Recommendation Database time: An optimal rate of data transfer is around 1 ms per record. CPU: Programs with over 50% CPU time should be examined in greater detail with the ABAP Trace or Debugger. The following SAP Notes provide additional information about this tool: SAP Note Runtime parameter of the statistics collection SAP Note FAQ: RFC Statistics in Transactions ST03/ST03N and STAD SAP Note Definition of SAP response time/processing time/cpu time How to use STAD in FS-PM: Check if the RFC is the bottleneck when executing update runs. Check the memory watermark, calculate your possible maximum concurrent job number for update runs. Provide statistical data for analysis from which you can derive promising areas for performance tuning Performance Trace (ST05) Performance Trace (ST05) is used to analyze the database access to find which DB tables are performance bottlenecks. A general introduction to Performance Trace can be found in the ABAP Workbench Tools directory - Performance Trace. Useful functions to analyze the performance trace file: Display Statement: Show the values of the variants in an SQL statement. 50

51 Display DDIC Information: Display the properties of the table, such as the size, buffering information, index and primary key. Display Execution Plan: Display the access strategy, which index is used. In this function, the information of hits is also provided. This functions varies widely between databases. Display Call Hierarchy: Show the ABAP call hierarchy of this SQL statement. Some functions of Performance Trace (ST05) are embedded in Single Transaction Analysis (ST12). The following two indicators reflect the performance of a single record: Identical returned records: High number of identical returned records must be avoided. SQL statement execution time: Single SQL statement with long execution time must be examined. The above two points can also be checked in ST12 trace files. Caution Please also note that each application server only has one active trace file. When a user uses ST05 to trace any object, make sure that no other batch processing or update tasks are running in parallel on the same sever. The trace file shows useful information of a SQL statement, such as the duration of the database operation, the name of the table, and the number of records returned by the database SQL Monitor (SQLM) SAP provides a new tool called SQL Monitor with which you can find out about SQL performance optimization potential in a productive environment as of ABAP 7.02 SP12. You can activate the monitor to get SQL footprints of real business operations. Since data collection from business transactions is asynchronous, the impact of the tool on the performance of production systems is negligible. For information about the use of the SQL Monitor, see: SAP Note SCN Blog SQL Monitor Unleashed SCN Doc The New SQL Monitor 51

52 4.2.4 Single Transaction Analysis (ST12) The Single Transaction Analysis tool (ST12) records the hit list and runtime of the ABAP program in a single transaction. The calling hierarchy can be displayed in a certain depth and width to show which method of which class calls which method. The typical use case of ST12 to identify and solve performance issues is described in Section Performance Analysis (SAT) This section explains how to use SAT to trace background jobs. Take the update run as an example. The most important setting in SAT for tracing background jobs is Max No. of Ached. Measurement. The other parameters can be set to the default value. Use the Schedule button to set the parameter for this trace. If the background run of update is set to be processed by a certain number of jobs and n intervals, the parameter Max No. of Ached. Measurement in SAT should be set to 2 n+2. 1 is for /PM0/FPP_START and 1 is for RBANK_PROC_START, which contains the preparation programs for the update run. The number 2 n is for RBANK_PROC_START and RBANK_PROC_END, which runs the real logic unit work for the update run. For further information about optimizing the performance of ABAP objects in transaction SAT, choose Tips & Tricks on the initial screen. There you will find best practices for ABAP programming Memory Snapshot Analysis (SMI Memory Inspector) SAP provides a memory inspection tool to check memory usage and find memory problems. This tool is called Memory Inspector (transaction code SMI). The Memory Inspector offers the following functions: Display memory snapshots in various ways. Compare memory snapshots and display the results in various ways. Save memory snapshots on the presentation server and load them from there. For detailed information, see Memory Inspector on SAP Help Portal and SAP Note Analysis of memory consumption. Recommendation To create memory snapshots for background jobs in the in-force business process update run, you can set user parameter /PM0/3FT_DEBUG_LEVEL = 1. Memory snapshots will be automically created. 52

53 Recommendation To create memory snapshots in dialog mode in the in-force business process update run, set a breakpoint in function module /PM0/ABY_FPP_FP_PA_INTERVAL. Then use ABAP debugger to create it Enterprise Service Performance (SoapUI) SoapUI is a free and open-source, cross-platform testing solution. With an easy-to-use graphical interface and enterprise-class features, SoapUI allows you to easily and rapidly create and execute automated functional, regression, compliance, and load tests. SoapUI is generally used for testing the performance of enterprise services of SAP Policy Management. With the load test, you can access all the parameters such as response time and request counts. Additionally, specified scenarios can be set by modifying threads number, limited time, and so on. For more details about how to do performance measurement on enterprise services, please see Section 6.2, Enterprise Service Performance Tracing Code Inspector (SCI) The Code Inspector is a tool for checking static ABAP coding and DDIC objects for performance, security, reliability, and statistical information. Recommendation Use check category Performance Checks to identify performance issues. Recommendation Create your own check variant with performance checks. For more information, see SCN Doc-Code Inspector User Manual. 4.3 FS-PM-Specific Debugging For information about general debugging techniques, see the SAP Performance Optimization Guide. To debug a background update run, firstly set the user parameter BANK_JC_DBG_MODE = DBG_BTC. 53

54 This section describes the method and steps for debugging background jobs of update runs. Take the update run as example. Set a breakpoint in advance. Select the specific background work process and choose Administration -> Program -> Debugging in SM50 to debug the update run. Set the parameter L_FLG_EXIT to X, then continue debugging in the subsequent executed program. Then continue debugging the background job to identify the problem Useful Breakpoint Finding the Process Model in the Workplace 1. Go to the Workplace and open Transactions. 2. Choose your transaction and double-click it. The attribute screen is displayed. Here you will find a command ID, which is an application-wide command. Copy it. 3. Open the meta models and then the process level. Double-click Cross-Application Commands. Enter your command ID. 4. On the next screen, you will see the information about the model. 5. Double-click the model. The Process Model screen is displayed. 54

55 Finding the Assigned Command when Choosing a BTX on the Screen Case A: Pushbutton. 1. Enter /h in the command field and then choose the pushbutton. 2. In the PAI of /PM0/SAPL3FCM_MAIN_DYNPROS, enter OK_CODE in the debugger. Press F5. 3. In OK_CODE you will find the command. Breakpoint example: /PM0/SAPL3FCM_MAIN_DYNPROS and the module pai_store_cmd. Case B: Choose a BTX in the ALV tree. This is more complex because the mapping of the ALV tree commands to the commands in PBT has to be done here. Add breakpoint in class /PM0/CL_3F_BPC_TREE->/PM0/IF_3F_BPU_CMD~DO_HANDLE_EVENT. Check entries in mt_cmd_map Important Classes in the Process Layer Business Process Manager: /PM0/CL_3F_BPU_MGR_O Business Process Model Manager: /PM0/CL_3F_BPU_MODEL_MGR_O Subcontroller: /PM0/CL_3F_BPU_CTRL (Factory is /PM0/CL_3F_BPU_SUBCTRL_FACM) Finding Out Where DB Tables Are Read Go to the Business Object model and look for the load strategy of the entity you are interested in. Then set a breakpoint in the method as required, such as the FIND method. It is possible that the real Select from the DB is not made in a method called GET_TABLE but, in the case of the policy holder, for example in /PM0/CL_ABP_DAA_POLHLDR -> /PM0/IF_ABP_DAU_DAO~FIND_SET (set the breakpoints here according to where the Select happens and subsequently a buffer table is filled). Go to the Entity model and view the Generation Data in the attributes screen. You will find the data access class here (/PM0/CL_ABP_DAA_POLHLDR is the data access agent for the policyholder). 55

56 Set a Breakpoint in /PM0/CL_ABP_CHECK_AND_DERIVE- >CHECK_AND_DERIVE Here 59 ****************************************************************************** 60 * 1. Step: Iterate over BO to modify the do_input_check and do_derivation-flags 61 ******************************************************************************* 62 IF lv_proc_status = mc_proc_all. Then look at /PM0/CL_3F_BOU_MGR_E->/PM0/IF_3F_BOM~ITERATE 148 * Execute 149 IF ls_entry-rdy = abap_true. 150 DELETE lt_pending_queue INDEX ln_count. 151 lr_boec?= ls_entry-node->boem lv_result = ir_vst->execute( ir_node = ls_entry-node 154 ir_parent = ls_entry-parent 155 ir_boec = lr_boec ). 156 If you look for special objects where you want to set breakpoints: Transaction SE18: Use BAdI definition /PM0/ABP_BCA_DERIVE_BADI. Go to the Extension Spot tab page and choose the interface /PM0/IF_ABP_BCA_DERIVE_BADI. Perform a Where Used List on method DO_INPUT_CHECKS. The list can contain the following entries: /PM0/CL_ABP_BCA_PROC_DERIV_STD /PM0/CL_DERIVE_ADJUSTMENT_BADI /PM0/CL_DERIVE_COV_BADI /PM0/CL_DERIVE_COV_LIFE_BADI /PM0/CL_DERIVE_POLICY_BADI /PM0/CL_DERIVE_POLPR_BADI /PM0/CL_DERIVE_POLPR_LIFE_BADI /PM0/CL_DERIVE_PREM_BADI /PM0/CL_DERIVE_TAXJOUR_BADI For example, set the breakpoint in class /PM0/CL_DERIVE_POLICY_BADI -> /PM0/IF_ABP_BCA_DERIVE_BADI~DO_INPUT_CHECKS and run the New Business business process. 56

57 Breakpoints for Time Model Choose corrresponding methods of class /PM0/CL_ABZ_BPU_TM_TIMEMODEL for the time model itself and classes of the form /PM0/CL_A*Z_BPU_TMF* for the time model functions. Be aware that time model functions make massive use of inheritance, so in some cases in might be necessary to set the breakpoint in one of the superclasses (A*Z_*TMF*MASTER*) Breakpoints for Journal Class /PM0/CL_ABJ_0_PRC_DISPATCHER with the respective methods (in case you want to create a Business Object Application Journal Entry out of the actual contract version: breakpoint in method /PM0/IF_ABJ_0_PRC_DISPATCHER~CREATE_APL_BY_HIGHEST_VERS). Otherwise just read the short text of the names of the interface methods Other Breakpoints FS-PM has a number of built-in breakpoints. You can use the user parameter /PM0/3FT_DEBUG_LEVEL to break or raise exceptions at certain positions. FS-PM also provides various checkpoint groups to make it easy to debug business-specific topics. Use transaction SAAB PM0/* to search. Combine with the PBT workplace. Example Find executable class for PBT layers: Use Where-Used-List. 57

58 Find Loader Class of BO Debugger Script (SAS) Analysis of memory usage: RSTPDA_SCRIPT_MEM_TOP Stop at spec. DB table: RSTPDA_SCRIPT_BP_SELECT_TAB 58

59 Stop at read internal table: RSTPDA_SCRIPT_BP_READ_TAB Useful links: SAP Help Debugger Scripting SCN Blog ABAP Debugger Scripting Basics 4.4 Typical Use Case Study This section introduces typical examples of how to use the tracing tools to identify and solve performance problems in FS-PM systems Identifying Database Issues The main issue seen in customer extensions is that they often redundantly access data that has already been read by the same or another extension, or by SAP standard coding. While redundant data access occurs in most processes, the number of incidents should not be allowed to reach a level that causes a significant increase in runtime. If this is the case, it is necessary to buffer information in the application. The other issue that often occurs is data access bypassing the indices. This issue usually remains unnoticed, because the first runtime measurements are done on a system with only few entries in tables, and later the table can become very large in the production system. It is therefore necessary to verify the existence and the use of the right index for every SQL statement added to an enhancement. Example The following example shows how to identify any existing database issues by using transactions SAT and ST05. First identify the root cause of the issue: 59

60 A set of trace results compiled in Runtime Analysis (transaction SAT) shows that in a MaxDB system the two SQL statements account for around 84% of the net time used, which amount to approximately 250 and 165 seconds respectively. In /PM0/CL_ABP_SEARCH_TOOLKIT->GET_PRECON_ON_EFFECTIV_DT( ): Code fragment: SQL statement In /PM0/CL_ABP_SEARCH_TOOLKIT->GET_APPLICATION_FOR_PRECON( ): 60

61 Code fragment: SQL statement The two SQL statements use or and non-equal conditions to select the corresponding values to the internal table. As a result, for each select of this transparent table these two SQL statements will take a long time to find the value meeting the search condition. In ST05, the time consumed by each of the SQL statements is displayed, which is around 1 second for each Select. Besides, there is no index matching the condition of the SQL statement, and the transparent table already has 4 indexes. So, adding another index will not reduce the search time of the SQL statement. Apparently, these two methods containing the two SQL statements will not use all of the fields in the transparent table. So, selecting only the fields actually used and copying them to the corresponding internal table may reduce the time needed for processing. Solution of the issue: Break down both of the SQL statements into two SQL statements instead of using or as a search condition. Sort the internal tables by application_id and policyproduct_id and then delete adjacent duplicates according to application_id and policyproduct_id, in order to get the same internal table as the original one. 61

62 Only select the used fields of the transparent table in the following program: For lt_coverage_help, only select application_id and policyproduct_id. For lt_japl1role, select policy_id, policyproduct_id and application_id. See SAP Note Analyzing Internal Tables Use SAT and ST05 to identify any existing database issues. First identify the root cause of the issue. In MaxDB system, two loop statements take up 1.39% of the total time, which is approximately 7 seconds. SAT trace result of internal table loop in MaxDB In /PM0/CL_ABP_SEARCH_TOOLKIT->GET_PRECON_ON_EFFECTIV_DT( ): Code fragment: the first nested loop 62

63 Code fragment: the second nested loop The two statements loop the same internal table with the same condition fields. The internal table lt_pol is defined as a standard table and before these two loops, the internal table is sorted by the fields of policy_id, policyproduct_id and journalno_id with a descending sequence. Code fragment: type of internal table lt_pol Code fragment: sort statement of the internal table lt_pol Besides, the internal table lt_pol includes all 49 fields of the DB table but only six of them are necessary in this method. And, in the loop statement, a line of the internal table lt_pol which satisfies the condition is copied to a structure. You can solve the issue is as following: Redefine the internal table lt_pol to sorted table type with three non-unique key fields which belong to DB table /pm0/abdjpol and are used in this method. Create a new internal table type which only includes the used six fields of the DB table /pm0/abdjpol and redefine the internal table lt_pol as well as lt_pol1 to this new internal table type. Create a field symbol to replace the structure which is used as a copy area in the loop statement. See SAP Note

64 4.4.3 Memory Runtime Type Creation Dynamically Create Internal Tables, Structures and Reference Some classes are used to create internal tables, structures and reference classes dynamically at runtime. But some of the methods in this service can lead to a memory leak in runtime. These are: CL_ABAP_TABLEDESCR, methods CREATE and CREATE_WITH_KEYS CL_ABAP_STRUCTDESCR, method CREATE CL_ABAP_REFDESCR, methods CREATE and CREATE_BY_NAME These methods may repeatedly create table types with an identical line structure, therefore new entries will be entered into the classes attributes. This memory is allocated by the ABAP kernel and most of it corresponds to memory objects which represent the numerous table types created in the program. The kernel memory is not controlled by the ABAP garbage collector, and it is often only released at the end of the user session. So the memory issue occurs. Since release NW 7.02, there are corresponding GET methods which make use of an internal cache. These GET methods are therefore much more efficient with regarding to memory and CPU consumption. SAP Notes and address this issue. Process BAdI instance in class CL_EXITHANDLER In SAP Note , a cache was installed in the classic BAdI in order to improve the performance. The cache works well if the BAdI is used as intended. It means that with CL_EXITHANDLER=>GET_INSTANCE, a BAdI proxy is created once (more specifically, once for each implementation instance to be created). Later you can call the BAdI methods as often as required. If CL_EXITHANDLER=>GET_INSTANCE is called very often (for example, in a loop), the cache is filled up with an increasing number of implementations, even if they will not be required again. A typical example of incorrect usage: In a loop, the system always calls CL_EXITHANDLER=>GET_INSTANCE first and then the BAdI method. 64

65 So the solution is to avoid calling CL_EXITHANDLER=>GET_INSTANCE with a very high frequency. As for the detailed solution, please refer to SAP Note Redundant Logic Constrain condition In previous FS-PM releases, there are cases of using the condition statements to filter out the unnecessary logic. Use class attribute as buffer Structures and internal tables can be used as class attributes to buffer the frequently called values. Therefore, the time consumption of multiple identical method calls with a high number of hits and SQL statements could be avoided. Optimize batch mode FS-PM can process policy information either in dialog process mode or in batch process mode. Normally the dialog mode-related classes are called by the dialog business transactions since almost all the values including the derived fields are required to be displayed in the screen. The batch mode related classes are used in background processing, such as update runs and enterprise services. So, by simplifying the logic and eliminating transient fields, you can make the batch mode run faster than the dialog mode. Case: Integration interface of FS-PM and FS-CM 65

66 In Claims Management, when creating claims it is necessary to get the policy information from Policy Management through RFCs. In previous versions, the remote-enabled function module (RFM) /pm0/abt_cm_policy_details creates dialog mode-related class instances to get the policy information. A comparison of the information required by FS-CM from this RFC by using batch mode and dialog mode shows that there is not much difference because no additional derived fields are displayed on the screen. Since batch mode works much faster than dialog mode, using batch mode is better for performance. So, by changing the value of variant lv_run_mode to batch, the RFC gets policy information through batch mode class instances. Note Since the logic and required fields of business objects are different between dialog and batch mode-related classes, these two modes are not always interchangeable. But if only the transient fields affect the business transaction, then there is a method that could help to get the transient value under batch mode: /PM0/IF_ABP_XI_TOOLKIT~DO_TRANS_EASY( ). 66

67 5 Integration of FS-PM with Other Systems There are two cases of integration. One is to use the standard integration provided by SAP, in which case the buffer can be used. The other is to integrate with third-party components instead of standard SAP components, in which case buffers are only available when the corresponding integration classes are used. 5.1 FS-PM Architecture Figure 1 describes the most important internal components and their interaction with each other. For detailed information, please refer to the FS-PM architecture blue book. Core Functionality Process Adapter Integration Interfaces Components Basis Processes Product Interface Basis Services Basis Tools Exits (BadIs, Business rules, etc.) Basis Infrastructure Core Business Data NoneCore Data NoneCore Data NoneCore Data Figure 1 FS-PM: Components Overview 67

68 5.2 API Communication In most cases, the integration between FS-PM and other components uses RFMs. So, the time spent by RFCs plays a very important role in the performance of integration in SAP Policy Management. Generally, if the data transfer between the systems is large, or the network connection is not good, it can become a bottleneck. To avoid such a situation, you can either transfer data as bulk within one RFC instead of transferring items individually with multiple calls, or make full use of the RFC waiting time and the time spent on data processing on the external systems. The asynchronous RFC may be a good approach. When you start to implement an RFM, you should use this as an integration principle: First, reduce the number of RFCs (i.e. bundle the calls as much as possible). Secondly, try to keep the number of individual RFCs as low as possible. Note The RFCs will fail if the target systems do not have dialog work processes. So make sure there are sufficient dialog work processes in the target systems Accessing Policy Data via Remote Function Call If you need to access policy data from outside the system (to display the data in a portal, for example), a generator is provided to dynamically create a function module that provides only the requested data. The input parameters of this function module are the policy number and technical ID. The user who calls the function module can also decide which entities are required, and for which entities derivations need to be executed. Since the generator uses a flexible concept for enhancements, you can also attach other data sources. This function is designed to allow the creation of customer-specific Web services in portal environments. To start the generator from the SAP Easy Access screen, choose SAP Menu -> Policy Management -> Tools -> Generate Access to Policy Data or call up transaction /PM0/AB_INQUIRY_FUMO Example for Asynchronous RFC For asynchronous RFCs, the calling program executes the statement CALL FUNCTION. As soon as the remotely called function starts in the target system, the calling program continues with other operations without having to wait for the RFC to be finished. 68

69 For the integration between FS-PM and FS-CM, function module /PM0/ABT_CM_FIND_COVERAGES is a good example where an asynchronous RFC is used. In this function module, another function module /PM0/ABT_CM_POLICY_DETAILS is called asynchronously, which is used to get contract details according to policy number. The performance is improved by parallel processing Example for Bundled Synchronous RFCs For the implementation of RFMs, bulk processing can greatly improve the performance. The following example illustrates the effect: Assume the getlist method returns 50 BO instances. For each BO instance, you need to perform a remote service call. The minimal call time of an enterprise service is about 20ms, for 50 BO instances, which amounts to 20x50ms = 1000ms without achieving anything. With this approach, you will never reach a UI response time under one second. A better implementation of this API is to implement a getdetails method (note the plural), which retrieves the details of all BO instances returned by the getlist call. Together with a bulk-enabled enterprise service, you could retrieve the same information with only two service calls taking a total of 100ms, which gives you a theoretical UI response time of one tenth of a second, thus saving time Enterprise Services In SAP Policy Management, enterprise services are provided for integration with other components. For more information about the available enterprise services, please refer to the SAP Library for SAP Policy Management at Choose path Integration-> Enterprise Services for SAP Policy Management. Also you can refer to the following SAP Notes for details about those enterprise services: SAP Notes Additional information about FS-PM 5.3 Enterprise Services SAP Notes Additional information about FS-PM 5.3 SP01 Enterprise-Services In Section 6.2 you can find information about how to trace enterprise service performance. Note To improve performance, do not retrieve data that you do not need. For example, when use enterprise service Retrieve Insurance Policy, you can restrict the corresponding business object information with the transmission request code. 69

70 5.3 Decoupled Components SAP Policy Management (FS-PM) is embedded in the SAP for Insurance landscape, and it uses interfaces to communicate with other applications such as BP (Business Partner), FS-CD (Collections/Disbursements), FS-CM (Claims Management), FS-ICM (Incentive and Commission Management), FS-RI (Reinsurance), and so on. In each subsection of this section, you will find classes and interfaces used for the integration with FS- PM. The RFMs used for communication between components are embedded in the methods of the classes. It is recommended to use these methods instead of calling the RFMs directly, in order to make use of the class buffer. You can find corresponding functions in the description of the method in the system. Avoid redundant RFCs and program calls in the implementation Business Partner (FS-BP) Package: /PM0/ABT_BP Classes and their interfaces for integration with external systems: /PM0/IF_AB_INT_BP /PM0/CL_AB_INT_BP_640 /PM0/CL_DEF_IM_ABP_BP_BADI Collections & Disbursements (FS-CD) This system handles the payments that need to be received or paid. If the planned payments are not received, the CD component FS-CD will trigger a dunning procedure. Package: /PM0/ABT_CD Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_CD /PM0/IF_AB_INT_APPROVE /PM0/IF_AB_INT_CD /PM0/CL_AB_INT_CD_ACCESS_REM /PM0/CL_DEF_IM_DUNNING_CD_BADI /PM0/CL_DEF_INT_RFC_CD_BADI /PM0/CL_DEF_RFC_CD_GET_IO_BADI 70

71 5.3.3 Claims Management (FS-CM) Claims Management handles the claims related to insured events, for example. Package: /PM0/ABT_CM Classes and their interfaces for integration with external systems: /PM0/IF_ABT_CM /PM0/CL_ABT_CM_BNFINF_REM /PM0/CL_ABT_CM_CRTBNF_REM /PM0/CL_ABT_CM_JUMPCM_REM You can use this function module to get policy details on the basis of the policy number: /PM0/ABT_CM_GET_POLICY_DATA Note With the following SAP Note, you can define a new update type to be used instead of the previous update type STD for the positioning of a contract as part of the FS-CM interface: SAP Note FS-CM integration runtime improvement: Enabling use of new update type for "simplified" positioning Incentive and Commission Management (FS-ICM) Incentive and Commission Management (ICM) is a solution that enables incentive and commission processing for employees and partners. You can improve the performance of transferring fields of entities between FS-PM and FS-ICM with Customizing Policy Management -> Integration -> Incentive and Commission Management FS-ICM. Please refer to Section Note ICM was previously named Commission System. Package: /PM0/ABT_CS Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_CS /PM0/IF_AB_INT_APPROVE /PM0/IF_AB_INT_CS /PM0/CL_AB_INT_CS_REMOTE /PM0/CL_AB_INT_GETCSDATA_FALLB /PM0/CL_AB_INT_GETCS_FALLB_604 71

72 /PM0/CL_AB_INT_TRANS_FALLBACK In the Change business process, each ICM-relevant business transaction creates a commission case. To increase the performance of data exchange between FS-PM and FS-ICM, you can bundle multiple ICM cases of a policy into a single remote function call. The same applies for the update run. You can activate this function with the Customizing activity Policy Management -> Integration -> Incentive and Commission Management FS-ICM-> Incentive and Commission Management FS-ICM. In this Customizing activity, select the ComnBuffer checkbox.: Note: To use this function, you must have activated the commission case buffer in FS-ICM for the current commission application, by setting Use Buffer to true in the FS-ICM Customizing activity SAP Insurance -> Commission -> Incentive and Commission Management -> Processes - Commission Case -> Activate Commission Case Buffer. Otherwise, commission cases could be lost. For business processes such as New Business, Universal Change, Reset, and Reversal, the buffering has no impact since each of these business processes creates one single commission case at the most, therefore the number of RFCs will not change. Please be aware that the bundling is only done for one policy, due to the existing qrfc concept for the SAP Policy Management interfaces Loans Management (FS-CML) As of FS-PM 5.3, the integration with FS-CML is available for policy loans related to insurance contract. Further external systems support the integration of FS-PM with FS-CML: For policy loans, FS-CML is integrating with FS-CD instead of FI. FS-PM is integrated with Claims Management (FS-CM) to settle the policy loan. Package: /PM0/ABT_CML Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_CML /PM0/CL_AB_INT_CML_ACCESS /PM0/CL_DEF_INT_WRITE_CML_BADI (see the BAdI definition: /PM0/ABT_WRITE_CML_BADI) Package /PM0/AOOL_LOAN Classes and their interfaces for integration with external systems /PM0/CL_AOOL_LOAN_CONTRACT 72

73 /PM0/CL_AOOL_LOAN_CONTRACT_CUS The number ranges in FS-CML should be buffered for performance reasons. In Section of this guide, you will find more information about the number range. FVVD_KOBJ Loan object key FVVD_RANL Number range for loan number FVVD_RPNSP General daybook no. FVVD_PNNR Daybook no. loan FVVD_BEKI Loan: Document number of the document header VDBEKI Reinsurance (FS-RI) Package: /PM0/ABT_RI Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_RI /PM0/IF_AB_INT_RI /PM0/CL_AB_INT_RI_REMOTE Financials (FI) Package: /PM0/ABT_FI Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_FI /PM0/IF_AB_INT_FI /PM0/CL_AB_INT_FI_REMOTE Accounting Component: uses interface /PM0/IF_AB_INT_AC Organizational Management (PD-Org) Theoretically, the OM could be on a different system from FS-PM. It can be located on a peripheral system. Having the OM in a remotely connected system will cause performance problems. Therefore we recommend having it in the local system. Package: /PM0/ABT_OM Classes and their interfaces for integration with external systems: 73

74 /PM0/CL_AB_INT_OM /PM0/IF_AB_INT_OM /PM0/IF_AB_INT_OM_SHLP /PM0/CL_ABT_OM_HANDLER /PM0/CL_AB_INT_OM The system derives the responsible organizational units from the rules that you have implemented in a BAdI. You can make the settings for this BAdI in Customizing for SAP Policy Management under Integration -> Office Automation -> Organizational Management -> BAdI: Derivations of Organizational Assignments. If Portfolio Assignment (PFO) is actively integrated, the system stores and manages the organizational units assigned to the policy in Portfolio Assignment. In this case, you can also change these organizational units independently of FS-PM in Portfolio Assignment. For more information, see Integration with Portfolio Assignment PFO Portfolio Assignment (PFO) If you have activated portfolio assignment in FS-PM, you can manage the relationships between policies and commission contracts, and between policies and organizational units in portfolio assignment. The changes to these relationships can be accessed independently of FS-PM through portfolio assignment, as well as through FS-PM. Package: /PM0/ABT_PFO Classes and their interfaces for integration with external systems: /PM0/CL_AB_INT_PFO /PM0/IF_AB_INT_APPROVE /PM0/IF_AB_INT_PFO /PM0/IF_AB_INT_PFO_COM /PM0/IF_AB_INT_PFO_OM /PM0/CL_ABT_PFO_GETSEG_BADI /PM0/CL_ABT_PFO_READ_BADI /PM0/CL_AB_INT_PFO_OM_REMOTE /PM0/CL_AB_INT_PFO_REMOTE Customizing You can make the settings for this in Customizing for SAP Policy Management under Integration -> Portfolio Assignment PFO -> Define Interface to Portfolio Assignment. 74

75 Correspondence Package: /PM0/ABT_CORR Here the interface /PM0/IF_AB_BPU_COR_CTRL is used. The processing of correspondence can be improved with regard to performance by using the correspondence cache. For more information, see Section of this guide Business Intelligence (BI) You can use this function to format BI-relevant data. The function starts Framework for Parallel Processing (FPP). The system writes data from the following components into the delta queues: In-Force Business Management Object Management Master Policy Coinsurance Customizing Policy Management -> Integration -> Business Intelligence (BI) -> Define Entities for Transformation Run BI You can define whether the system should format an entity in a transformation run before transferring it to the BI system. Policy Management -> Integration -> Business Intelligence (BI) -> Define Transfer Mode for Transformation Run You can configure which transfer mode is to be used for the transformation run. Policy Management -> Integration -> Business Intelligence (BI) -> Business Add-Ins (BAdIs) -> BAdI: Data Manipulation of Line of Business Expansions You must implement this BAdI to expand the LoB for the transformation run of in-force business management Product and Quotation Management (FS-PQM) For an overview of FS-PQM see 75

76 Product Engine Each policy is based on a product that is defined in a product engine. For this reason, SAP Policy Management is always connected to a single product engine. The product engine defines products and their relationships and stores all calculation rules. Changes to an insurance policy or application may make it necessary to apply these calculation rules. Policy Management architecture is designed in such a way that certain steps for preparing a call are logically more or less separated from the steps themselves, depending on their results. Recommendation The product engine s interface for calculation is rather broad to enable maximum flexibility of the calculation. In order to prevent Policy Management from providing information that is not needed, we recommend to be as specific as possible in your own calculation methods. This avoids the unnecessary reading of data. The following product engines are commonly used: msg.pm SAP Product Lifecycle Management for Insurance 2.0 (FS-PRO) You can also connect to other product engines. Note Only one product engine can be connected to one FS-PM system. The integration of multiple FS- PRO systems, or multiple msg.pm systems, with one FS-PM system is not possible msg.pm You can refer to the guide on how to set up msg.pm with good performance on SAP Support Portal. First you should download the FS-PM release or SP, and you will find the performance guide in the zip file PM_ X.zip (Documents\English\PMDesigner\PDF\PMM10PerformanceGuide_34.pdf). Document: Sample Products: Life Insurance in msg.pm Document: Sample Products: P&C/Non-Life in msg.pm You can improve the performance of serialization to msg.pm with the Customizing activity Policy Management -> Integration -> Product Engine -> Connection with msg.pm -> Optimize Serialization Runtime. Please refer to Section In order to reduce the data amount transferred to msg.pm, the following logic has been implemented in the msg.pm adapter: 76

77 Only fields that are really used in the context of a particular product module in msg.pm will be transferred. To make the most out of this improvement, SAP recommends adding only the minimum subset of required fields to each product module. Fields that contain a value that is equal to the default value configured in msg.pm will not be transferred. SAP recommends to set default values in msg.pm wherever possible to further reduce the data volume transferred through the msg.pm interface Integrating Product Engine (FS-PRO) Integration Guide with FS-PRO: Use of Product Engine FS-PRO 77

78 6 Appendix 6.1 Example of Application Interface Example Demo program producing Personal Accident policy with multi-contracts and multi-coverages Selection Screen The check boxes are used to specify the policy status. Parameter EXECS is used to determine the number of policies to be created. Contract Amount and Coverage Amount are the number of contracts a single policy has and the number of coverages that are included in a contract. Personal Accident Policy with 5 contracts, each contract with 5 coverages. 78

79 Recommendation Function module /PM0/ABT_APIF_REL_FB has 91 table type parameters that cover almost all the attributes of a policy. This means you can create any kind of policy defined in the product template. In this case, only basic attributes are entered since only the contract and coverage number is required. The following BO values are entered: ABWAAPPLPOL COMMIS COMROLE COV SUBJCT ADR COVCPCO POLHLDR POLICY POLPR REPVAL PRMPAYER 79

80 PREM CLAUSE EXTENSION ERRORS ABEACS NOT every field of the above structures of BOs is mandatory. And the BOs that need to be filled varies according to the definition in the product template. Insufficient or superfluous input will cause policy creation to fail. Here are some tips to identify the mandatory input parameters: 1. Take all the input fields that are mandatory when creating a policy manually in the New Business business process as a reference. 2. Values of the BO database table entries, for example /PM0/ABDAPOLICY. For details please refer to the sample program. Demo Reports: ZZZ_GEN_MASS_POLICY_CB ZZZ_GEN_MASS_POLICY_FC ZZZ_GEN_MASS_POLICY_LK ZZZ_GEN_MASS_POLICY_PR ZZZ_REPLAN_MASS_JOBS Note If the input parameter IF_IDEMPOTENCE is set in the APIF, the secondary index PGN for table /PM0/ABDAPOLICY should be activated to avoid performance issues: 80

81 6.2 Enterprise Service Performance Tracing This section describes how to trace an enterprise service (ES) both in the SAP system and in the SOAPUI for performance tuning, including instructions for the related tools and functionalities. This section also provides more information about the initial load runtime measurement. For more information about SOAPUI, see Background for Initial Load To measure the initial load runtime, you select a policy that has not been retrieved since the buffers were last cleared (usually weeks or months). In this way, it does not benefit from the database buffer and you can measure the runtime without the DB buffer. Normally the system buffers Customizing and framework data as well as the transaction data. Because of this, clearing the whole system buffer before every measurement will not produce the required result. To make sure buffered Customizing and framework data does not distort the measurement, you need to use copied policies for testing. 81

82 6.2.2 Preparation This section describes how to generate test data (policies) and how to configure the parameter setting in SOA and SOAPUI (Ver ). The preconditions for testing are that the enterprise service is configured and usable, and related testing data should be available Identical Policies (Initial Load Only) Here the sample policy is used to created identical policies. Open TCODE /PM0/ABC_N, input 61 (an example) in Sample Application field, click the button. Then click to create a new policy. Repeat these steps to prepare at least 5 policies SOA Part (SAP System) Open SOA Management (transaction SOAMANAGER). The SOA Manager opens in a browser window. Then select option Web Service Configuration. For example, enter the Web service name /PM0/INSURANCEPOLICYFSBYIDENTI in the Object Name field, then press Enter. Click the name in blue to go to the configuration page. 82

83 There are 2 services provided. Here we use the first one as an example. Click the icon to display WSDL information. Write down the WSDL URL address for later use. It is better to switch the SOAP Version to SOAP 1.1 and SOAP 1.2 if it is not already chosen. 83

84 SOAPUI Part 1. Start SOAPUI, click the menu bar to create a new SOAP project. 2. Enter the initial WSDL with the WSDL address taken from SOA Management. Then click OK. 3. Enter basic authentication information for Username and Password in the popup window, usually the user ID for the corresponding SAP system. Click OK. 4. The configured service appears in the left panel under Projects. 5. Right-click on the request, choose Add to TestCase in the popup menu. 84

85 6. Enter the names of TestSuite and TestCase. 7. Keep the default setting in the popup window Add Request to TestCase. 8. Double-click the TestCase node. The TestCase editor window is displayed. 85

86 9. Click the icon to enter authentication information of Username and Password for the TestCase. (Tip: Use a different user ID from the one you use to log into the SAP system to exclude the interference of irrelevant processing from measurement). Leave the Domain area blank. 10. Click the icon to send the request. The result is displayed in the right window. 86

87 Now all the preparations are done Measurement Strategy (Initial Load Only) Choose a policy created during preparation, retrieve it several times in SOAPUI to make sure all related framework and customized DB buffers are loaded properly. Then choose a new policy to measure the runtime. This procedure ensures that the transaction data for the second policy is not buffered, which enables a correct measurement of the time required SAT 1. Open SAT in the SAP system (transaction SAT). Click the button. Enter the information of Short Description. 2. Create a new schedule by clicking the icon. Set the External Session, Process Type and Object Type to Any. Then click to finish the creation process. 87

88 3. You now receive a scheduled measurement with the status In Process, which can be checked out in the Overview of Scheduled Measurements. 4. Then execute the request in SOAPUI. The status of the measurement will change to Executed after clicking the icon. 5. Return to the Evaluation tab, where the measurement result is shown ST12 Open ST12 in the SAP system (transaction ST12). Set the Username to the one used to login the SOAPUI and Tasktype as *. Press Start trace then execute the request in SOAPUI. After ending the tracing, the measurement result will be displayed SOAPUI LoadTest Create a new load test in the project in SOAPUI. Click the icon to execute the test case. All the parameters should be set: Limit is the duration of the test. Threads is the number of threads that are raised by SOAPUI for testing. 88

89 After running, the result will be displayed. The time unit is milliseconds Troubleshooting In SOA Management, there is a function for tracing errors when enterprise services are executed. Open SOA Management and clicking the Logs and Traces tag. Select SOA Runtime Error Log. All runtime errors will be displayed here with the user ID and other parameters. Click the required row. Details of the error are displayed. 89

90 6.3 FS-PM Sizing Questionnaire 1. General Data How many users are logged during the peak hour? How many business processes are executed during the peak hour? (*see Question at 6 for clarification) How long is the time slot for the update run? For how many months do you have to update the policies in advance? Maximum Percentage of Policies to be updated within one run (not already updated be previous run)? (40% = 0,4) Are there dependency between contracts of the same policy? Are retroactive amendments required? How many years in the past? 2. LOB Life What is the total number of policies in LOB Life without Unit Linked? What do expect the number of policies to change within one year (40% = 0,4) What is the average number of contracts per policy without Unit Linked? What is the average number of coverages per Non-Unit Linked contract? What is the average number of subcoverages per Non-unit-linked coverage? (Deckung/Teilvertrag) What is the total number of unit-linked policies in LOB Life? What do expect the number of policies to change within one year (40% = 0,4) What is the average number of contracts per Unit-Linked Policy? What is the average number of coverages per Unit-Linked contract? What is the average number of subcoverages per unit-linked coverage? (Deckung/Teilvertrag) What do expect the number of policies to change within one year (40% = 0,4) How many funds are used within the system? What is the share of policies that are part of group business? How long is the average payment frequency in months? Annually and semi-annually payments: Due on the same point in time, or distributed? 3. LOB P&C What is the total number of policies in LOB P&C? What do expect the number of policies to change within one year (40% = 0,4) What is the average number of contracts per policy? What is the average number of coverages per contract? What is the average number of subcoverages per coverage? (Deckung/Teilvertrag) What is the share of policies that are part of group business? How long is the average payment frequency in months? 90

91 Annually and semi-annually payments: Due on the same point in time, or distributed? 4. LOB Auto What is the total number of policies? What do expect the number of policies to change within one year? (40% = 0,4) What is the average number of contracts per policy? What is the average number of coverages per contract? What is the average number of subcoverages per coverage? (Deckung/Teilvertrag) What is the average payment frequency in months? Annually and semi-annually payments: Due on the same point in time, or distributed? Are retroactive amendments required? How many years in the past? How many insurance confirmations do you expect in the peak month? What is the average number of changes of insurer certificate per month? What is the average number of vehicle changes per month? 5. LOB Health What is the total number of policies? What do expect the number of policies to change within one year? (40% = 0,4) What is the average number of contracts per policy? What is the average number of coverages per contract? What is the average number of subcoverages per coverage? (Deckung/Teilvertrag) What is the average payment frequency in months? Annually and semi-annually payments: Due on the same point in time, or distributed? How many insurance confirmations do expect in the peak month? 6. How many business processes are executed during the peak hour? - details (in case you fill out here, don't enter cell B5) Number of New Businesses captured and released in Policy Management Number of New Businesses sent via "Application Interface", calculated and Released in Policy Management Number of New Businesses sent and calculated via "Application Interface", Released in Policy Management Number of Renewals Number of Changes captured and released in Policy Management Number of Changes send via "Interface" and released using in Policy Management-dialogues Number of Changes captured and stored as application (not released) Number of Inquiries? Number of Reversals & Cancellation? Number of Resets? (Annulment of the current policy status and simultaneous reactivation of an older policy status.) Number Of Searches in Peak Hours? 91

92 SAP SE or an SAP affiliate company. All rights reserved. No part of this publication may be reproduced or transmitted in any form or for any purpose without the express permission of SAP SE or an SAP affiliate company SAP and other SAP products and services mentioned herein as well as their respective logos are trademarks or registered trademarks of SAP SE (or an SAP affiliate company) in Germany and other countries. All other product and service names mentioned are the trademarks of their respective companies. Please see for additional trademark information and notices.