Solve Performance Optimization Problems with the QorIQ Optimization Suite Scenarios Tool

Transcription

1 Solve Performance Optimization Problems with the QorIQ Optimization Suite Scenarios Tool FTF-SDS-F0201 Jessica Deery Software Developer, Digital Networking Sidharth Kodikal Software Developer, Digital Networking A P R TM External Use

2 Session Introduction Scenarios Tool is a Performance Analysis tool designed specifically for Freescale QorIQ network processors Provides System-Level Analysis and Linux User Space Application Analysis Simple to configure and easy to use Appropriate for beginners with little knowledge of the processor and advanced users who prefer a scripting interface Provides live analysis while the application is running and extensive analysis post-run Sidharth Kodikal - software developer and a co-author of this tool External Use 1

3 Session Objectives After completing this session you will be able to: Configure the Scenarios Tool to collect Performance Analysis data Visualize the Performance Analysis data as it is collected by the tool Analyze Performance Analysis Data to observe whether or not your performance is improving External Use 2

4 Agenda Overview of the Scenarios Tool and Terminology Measure Bareboard Cache Performance Measure Bareboard DDR Performance Measure Cache Performance for a Linux User Space Application Measure Bareboard Cache Performance using Python Interface Other Feature Highlights External Use 3

5 Scenarios Tool - Overview Optimized workflow for efficiently narrowing down performance issues anywhere on the system Customer Benefits System optimization for Cores and SoC Complexity abstraction Delivers Freescale expertise to users Ease of use Streamlined to solve several performance issues Key Features Stand alone no CodeWarrior needed Performance analysis including visualization Connection auto discovery Canned measurement scenarios 100+ scenarios covering Core and SoC blocks User-defined measurement scenarios Compare pairs of runs Graphically visualize all measurements Live view of events and metrics Supports bare metal or Linux applications Python scripting support Devices Supported P2040, P3041, P5020, P5021, P5040, P4040, P4080 T2080, T4240 B4860 Future Layerscape devices External Use 4

6 Scenarios Tool What Is a Scenario? A Scenario defines what performance data will be measured Aggregates Performance Monitor Events to be counted into cohesive groups Defines Metrics which are mathematical operations to be applied to the Event counts after the data is collected Optionally defines Python Scripts to perform additional target setup Stock Scenarios are canned Scenarios that are automatically included with the tool External Use 5

7 Scenarios Tool Available Scenarios Approximately Scenarios are available depending on the target Scenario Group What can I measure? CPU Utilization Branch Misses, Interrupt Counts, CPU Usage CPU Cache Cache Misses (Data/Instruction L1, Data/Instruction Backside L2) CPU - MMU TLB4K Reloads, VSP Reloads, L2 MMU Misses CPU - Core Complex CPU - Load Store Unit DDR CoreNet DPAA QMan DPAA SEC OCeaN Combination Core Complex Traffic Data Line Fill Buffer (DLFB) Misses DDR Traffic, Page Misses, Collisions CoreNet Traffic QMan Dequeue and/or Enqueue Counts Security Engine Utilization DMA Performance Broad measurements over the whole system External Use 6

8 Measure Bareboard Cache Performance External Use 7

9 Scenarios Tool Measure Bareboard Cache Performance Common customer question #1: How do I measure Cache Performance? For this example, we will measure the Cache Performance of two functions that manipulate an array in memory unsigned long long sumarraynonoptimal (int *array, int w, int h, int n) { unsigned long long ret = 0; int i, x, y; for (i = 0; i < n; i++) for (x = 0; x < w; x++) for (y = 0; y < h; y++) ret += array[y*w + x]; return ret; } unsigned long long sumarrayoptimal (int *array, int w, int h, int n) { unsigned long long ret = 0; int i, x, y; for (i= 0; i< n; i++) for (y = 0; y < h; y++) for (x = 0; x < w; x++) ret += array[y*w + x]; return ret; } Algorithmically, the functions produce the same result. However, we want to examine which function is more optimal External Use 8

10 Scenarios Tool Measure Bareboard Cache Performance (continued) In order to measure the Cache Performance, we first need to complete the following steps: 1. Add a new configuration 2. Setup the connection to the target 3. Add a Scenario to the configuration to measure Cache Performance 4. Run the configuration to measure the Cache Performance of an application (see Backups for application C code) External Use 9

11 Scenarios Tool Add a New Configuration To add a new configuration, simply press the New Configuration toolbar button New Configuration Button External Use 10

12 Scenarios Tool Configuration A default configuration is added to a project. The configuration is displayed in the lower right of the workbench Project Navigation Configuration External Use 11

13 Scenarios Tool Setup the Connection To setup the connection, use the Connection toolbar. Add a connection from scratch or search for connections on the subnet External Use 12

14 Scenarios Tool Connection and Target Autodiscovery Use the flashlight button in the Connection toolbar to automatically discover any connections on the subnet Filter Connections After adding the connection, click the Scan Probe link to discover the target and see if it is available Discover Target External Use 13

15 Scenarios Tool Add Scenario for Measuring Cache Performance Below the Connection settings is a toolbar for adding Scenarios to be measured. Press the (+) button to add a new Scenario Data Cache Scenario is added by default Use Toolbar to Add or Remove Scenarios External Use 14

16 Scenarios Tool Add Data L1 Cache Miss Scenario Use the filter to search for Cache Scenarios. Check Data L1 Cache Miss Scenario and press the OK button Filter Scenarios Toggle how Scenarios are Grouped External Use 15

17 Scenarios Tool Configuration The Data L1 Cache Miss Scenario now appears in the configuration. Uncheck the default scenario Data Cache Operations and save the configuration We are now ready to measure! External Use 16

18 Scenario Tool Start Measuring To start measuring, press the Launch button Once an Analysis Session is started, use the session toolbar to Start/Stop/Pause Sampling View Overall Session Status View Detailed Progress External Use 17

19 Scenarios Tool Analyze Results Below are snippets of the table results that are displayed when sumarraynonoptimal is measured. Results are filtered to core0 The next table shows the results when sumarrayoptimal is used From the result tables, we can see that the cache reloads and the cache miss rate for sumarraynonoptimal are significantly higher than sumarrayoptimal External Use 18

20 Scenarios Tool Compare Results Side-by-Side To further visualize the results side-by-side, right-click the results in the Performance Analysis view, and select Compare External Use 19

21 Scenarios Tool Compare Results Side-by-Side (continued) Below are the side-by-side results filtered to show the Data L1 Cache Reloads measured for both sumarraynonoptimal and sumarrayoptimal Non-Optimal Optimal External Use 20

22 Scenarios Tool Explanation of Results The non-optimal function accesses memory walking down the rows. Each access loads the cache with data, but only the first element in the array is used. Subsequent accesses cause the cache to be reloaded. 1,1 1,2 1,n 2,1 2,2 2,n. n,1 n,2 n,n The optimal function accesses memory by selecting a row. Each access loads the cache with data. It then walks the array by columns. The cache is not reloaded until you get to the end of the line. for (i = 0; i < n; i++) for (x = 0; x < w; x++) for (y = 0; y < h; y++) ret += array[y*w + x]; return ret; } Non-Optimal for (i= 0; i< n; i++) for (y = 0; y < h; y++) for (x = 0; x < w; x++) ret += array[y*w + x]; return ret; } Optimal External Use 21

23 Measure Bareboard DDR Performance External Use 22

24 Scenarios Tool Measure Bareboard DDR Performance Common custom question #2: How do I measure DDR Performance? For this example, we will use the same application from the previous Cache Performance example. However, now we will focus on the performance of DDR when the function sumarrayoptimal is used To visualize the performance of DDR, we will also update the Configuration to enable the Live Graph feature so that any changes in the DDR Performance are immediately visible in realtime while the data is sampled External Use 23

25 Scenarios Tool Add Scenario to Measure DDR Performance First we add a Scenario to the Configuration to measure DDR Performance. For this example we have chosen the Scenario DDR 1,2 Traffic with Hitgen Read and Write. Uncheck the previous Scenario Data L1 Cache Miss External Use 24

26 Scenarios Tool Enable Live View Next, we update the Configuration to enable the Live View. We check the option Enable Realtime Data Visualization When this option is enabled, data is collected and immediately displayed to a Live Graph on a best-effort basis External Use 25

27 Scenarios Tool Enable Continuous Sampling To further enable visualization, we update the configuration to enable continuous sampling. By selecting the option shown below, the data is sampled continuously until the session is stopped by the user External Use 26

28 Scenarios Tool Observe DDR Performance in Realtime Upon running the DDR Scenario, the Live Graph is immediately displayed. Extensive Live data, all presenting the behavior of DDR is scrolled across the graph from right to left External Use 27

29 Scenarios Tool DDR Page Miss Rates To further examine the DDR Performance, we filter the Live Graph to show just page_miss. Immediately, we see that the Page Miss Rates evaluate to 1, which means that we are currently counting 0 Page Hits for both DDR1 and DDR2. This indicates poor DDR Performance External Use 28

30 Scenarios Tool Optimizing DDR via BSTOPRE To optimize the DDR Page Hits, we will tweak DDR configuration value BSTOPRE. This value sets the duration that a page is retained after a DDR access. Please note that changing the DDR configuration can be complex. To simplify the process, we recommend the QorIQ Configuration Suite (QCS) and DDR Validation (DDRv) tools. Below is a picture of DDRv view that allows you to visualize validation and pick an optimal configuration. External Use 29

31 Scenarios Tool Optimizing DDR via BSTOPRE For this example, we will increase the BSTOPRE using the CodeWarrior for PA Register Details View. This view is shown below. For the P4080, the BSTOPRE bit field is specified in bits 18:31 of the DDR register SDRAM INTERVAL. External Use 30

32 Scenarios Tool Optimizing DDR Performance Before stopping the target to change the BSTOPRE value, we pause the Analysis session After increasing the BSTOPRE on the target and resuming the Analysis Session, we can observe an immediate decrease in the Page Miss Rates from 1 to 0.13 External Use 31

33 Scenarios Tool Explanation of Results In the previous example we optimized the Cache Performance but completely neglected performance of DDR Increasing the BSTOPRE value demonstrated an immediate decrease in Page Misses. In this case, the performance is benefitted by retaining the pages for a longer duration Remember, it is important to evaluate the performance of the system as whole and not focus on a single component External Use 32

34 Measure Cache Performance Specific to a Linux User Space Application External Use 33

35 Scenarios Tool Linux User Space Applications Analysis In addition to the bareboard measurements that we observed with the previous examples, the Scenarios Tool can be used to profile events for a specific Linux user space application or process Events correlating to pure kernel counters can also be measured, thus, allowing the performance analysis of the kernel itself External Use 34

36 Scenarios Tool Linux User Space Applications Analysis The tool and the kernel provide the capability to measure the following types of events: Hardware Events processor events such as cycles, instructions, cache-misses, branches, branch-misses Software Events kernel counters that measure the performance of the kernel itself Cache Events hardware events that provide more details about the cache performance such as loads, stores, prefetches, and misses External Use 35

37 Scenarios Tool Measure Cache Performance for Linux User Space Applications For this next example, we will use the same code from the previous examples to produce two small apps, sumarraynonoptimal and sumarrayoptimal that run within the Linux User Space. We will complete the following steps: Add a new Linux Configuration Specify the Target Name/IP, and probe the target for available measurements Specify the application that we want to measure Select the Hardware Event that we want to measure, cache-misses Run the Configuration and measure the data External Use 36

38 Scenarios Tool Add a Linux Configuration To add a new Linux Configuration, simply press the New Configuration toolbar button New Configuration Button External Use 37

39 Scenarios Tool Add a Linux Configuration Next, select the radio button to measure Linux application performance. Also, select the radio button to Create a new project and specify a project name External Use 38

40 Scenarios Tool Configure the Target Name/IP and Probe the Target Press the (+) button to specify the Target Name/IP Press the probe button to discover the target and discover any enhanced measurements that may be available for the processor External Use 39

41 Scenarios Tool Configure Profiling Mode To configure the Profiling Mode for this example, we do the following: 1. Select Profile an application 2. Use Browse button to browse for the application that we want to measure 3. Check Only count events External Use 40

42 Scenarios Tool Note about SFTP Server Note that the probe, remote file browsing, and remote process browsing functionality all depend on an SFTP server being previously deployed and enabled on your remote Linux target. This is available in the openssh package of the DPAA SDK (v1.2. or greater) External Use 41

43 Scenarios Tool Select Cache-Misses To keep this measurement simple, we check the Hardware Event cache-misses. Now we are ready to measure! External Use 42

44 Scenarios Tool Analyzing Results Upon running the measurement for both sumarraynonoptimal and sumarrayoptimal, we can see that the event count for sumarraynonoptimal is significantly higher than the event count for sumarrayoptimal External Use 43

45 Scenarios Tool Profile with Call-Graphs In addition to measuring the event counts, it is also possible to produce profiles with call-graphs. Merely uncheck Only count events to enable the call-graphs, and rerun the measurement External Use 44

46 Scenarios Tool Profile with Call-Graphs for sumarraynonoptimal Profile Data Columns: Symbol Column ELF image from which the symbols originated Command column the monitored process Shared Object column the privilege level and the symbol name observed when the running process was interrupted Overhead column - % of the samples collected from the corresponding function Privilege levels: [.] user level [k] kernel level [g] guest kernel level (virtualization) [u] guest OS user space [H] hypervisor External Use 45

47 Measure Cache Performance via Python Interface External Use 46

48 Scenarios Tool Measure Bareboard Cache Performance via Python Interface For this section, we will again measure Cache Performance. However, this time we will utilize the Python Interface. Let us begin by first covering the Python Interface basics: Overview of the Interface Starting the Python Environment Exploring the Model Exploring the Available Stock Scenarios We will then end by configuring and running the script measure_cache_performance.py External Use 47

49 Scenarios Tool Overview of the Python Interface The Python Interface is for the more advanced user who desires automation or prefers a scripting interface. The interface is built upon the Performance Analysis (PFA) software engine which is the same engine that is employed by the Scenarios Tool Eclipse-based UI Python Interface Scenarios Tool Eclipse-based UI PFA Engine Target External Use 48

50 Scenarios Tool Starting the Python Environment To start the interactive python environment, run the python script python.bat (python.sh on Linux) in the cdde/bin directory of the Scenarios Tool installation:..\cdde\bin>python.bat A module called pfautils is provided to aid in the exploration of the model, configuration, and collection. To load it type: >>> from pfa import pfautils >>> External Use 49

51 Scenarios Tool Exploring the Model To explore the model associated with the P4080 type: >>> model = pfautils.load_model("p4080") >>> model.list() The following data is then printed: 16BIT_EPU_COUNTERS: 16 Bit EPU counters 32BIT_EPU_COUNTERS: 32 bit counters built by combining two 16 bit EPU counters Categories: UI Categories Constants: Core0: A specific core of the processor Core1: A specific core of the processor Core2: A specific core of the processor Core3: A specific core of the processor Core4: A specific core of the processor Core5: A specific core of the processor Core6: A specific core of the processor Core7: A specific core of the processor External Use 50

52 Scenarios Tool Exploring Stock Scenarios To explore the Stock Scenarios supported by the model type: >>> model.find("measurements").list() The following data is then printed: Measurements: Stock measurements Counter Measurements: CORE_PERFORMANCE: Instructions and cycles for core 0 Groups: All Cpus: Counter Measurements: CPU(all,L1,BIU)_CPC(RWO-HM)_CNET(IO)_DDR(PH,PM): CPU(all,L1,BIU)_CPC(RWO-HM)_CNET(IO)_DDR(PH,PM)_noPC: DDR, L1, Core Complex, CoreNet (All): Measures DDR, CPU Cache, External Use 51

53 Scenarios Tool Measure Cache Performance via Script We will now run the script measure_cache_performance.py to measure the performance of an application that uses the function sumarrayoptimal. The script measures Cache Performance using the exact same Stock Scenario from the first part of the session, Data L1 Cache Miss. # Create a configuration based on a stock scenario stockscenario = pfa_model.find( Data L1 Cache Miss") config = stockscenario.create_configuration() You can see the Stock Scenario defined at line 46 of the script. To measure other scenarios, replace this text with a different Stock Scenario name (see Backups for full script text) External Use 52

54 Scenarios Tool Measure Cache Performance via Script (continued) Before running the script, you will need to make the following modifications: 1. Update the value cc_config to specify your tap type and ip address 2. Update the value processor_name to specify the processor that you will be measuring 3. Update the value workspace_path to specify where the resulting raw data will be stored 4. Update value report_file_path to specify the path to the file where the formatted data will be printed To run the script, execute the following lines: C:\{scenarios_tool_installation}\cdde\bin\python.bat C:\{script_location}\measure_cache_performance.py External Use 53

55 Scenarios Tool Measure Cache Performance via Script (continued) Upon running the script successfully, the following output is generated at the console: Measuring with Stock Scenario - Data L1 Cache Miss using cc_config gtap:jtag:0:fsl00ff79 FSL.Reset: active context set to = e500mc#0 RunControl: active context set to = e500mc#0 Registers: active context set to = e500mc#0 Memory: active context set to = e500mc#0 FSL.Reservation: active context set to = e500mc#0 Expressions: active context set to = ccs:1;0 Grouping: active context set to = e500mc#0 Writing samples to Otf file... C:/dev/scenarioPyWorkspace/python_2014_02_19_13_27_12/pfa.otf Sampling finished Printing report to file... C:/dev/scenarioPyWorkspace/scenarioReport.out Done!!! External Use 54

56 Scenarios Tool Viewing Results The resulting report can be opened to view comma-separated data values. Below is the data opened in Microsoft Excel and filtered to show core0 values The Cache Miss Rate measured by the python script matches the measurement that we previously captured via the Scenarios Tool UI External Use 55

57 Other Feature Highlights External Use 56

58 Scenarios Tool Create Your Own Custom Scenarios If you want to extend a Scenario or modify a Scenario, the Custom Scenario Wizard can be used. To start it, press the toolbar button to create a New Custom Scenario New Custom Scenario Button External Use 57

59 Scenarios Tool Create Custom Scenarios Next, specify the Processor and Name. Then select the Scenario that you want to modify. The wizard can now be finished to generate a new Custom Scenario External Use 58

60 Scenarios Tool Customize Events and Counters Below is the Custom Scenario Events tab. The Events tab shows what events will be measured on which counters Available Events Add/Remove Events Selected Events/Counters External Use 59

61 Scenarios Tool Customize Metrics Below is the Custom Scenario Metrics tab. This tab displays all the scenario metric names and full expressions Metrics Toolbar: Add / Edit / Remove Metrics External Use 60

62 Scenarios Tool Customize Metrics Note that new metrics can be added from scratch or derived from existing Stock Metrics. This is supported via the dropdown menu that is next to the (+) button External Use 61

63 Scenarios Tool Customize Metric Expression Upon pressing the edit button, you are able to modify the metric expression. Metric expressions are a combination of events, constants and mathematical operators External Use 62

64 Scenarios Tool Customize Initialization with Python Below is Custom Scenario Initialization tab. From this tab it is possible to optionally specify additional initialization via a python script External Use 63

65 Scenarios Tool Create a Blank Custom Scenario Alternatively a user can create a blank Custom Scenario. To begin, press the button start the Custom Scenario Wizard. On the first page of the wizard, specify the processor and press finish New Custom Scenario Button Finish External Use 64

66 Scenarios Tool Share Custom Scenario Upon creating Custom Scenarios, you may want to share Scenarios and/or share the results of a collection. This can be done via the Import and Export Wizards. To access the wizards, right-click a project External Use 65

67 Scenarios Tool Run Multiple Scenarios in a Sequence In previous examples, we ran a single Scenario. It is also possible to run multiple scenarios in a sequence. Merely check the scenarios and run You can monitor which scenario is running via the Analysis Session view External Use 66

68 Scenarios Tool Results Table and Companion Graph Previously we saw snippets of the Results Table. From the Results Table, you can enable the Companion Graph which displays a graph that is linked to the current column selection in the Results table Click a table cell to show an annotation in the graph. Alternatively, drag an annotation to highlight a table cell Click to open the Companion Graph External Use 67

69 Scenarios Tool Result Graphs and Summaries In addition to the Results Table, results can also be viewed as multiple Graphs or bar-chart Summaries. Summaries display just the min, max, and average External Use 68

70 Conclusion External Use 69

71 Summary The Scenario Tool provides a way to easily measure system performance and the performance of a Linux User Space Application It is appropriate for users of all levels, beginner to expert For those wishing to extend the tools capabilities, features such as the Python Interface and the Custom Scenarios can be utilized When analyzing the results, remember to use the Compare feature to further simplify analysis To fully optimize the system, it is important to measure multiple components of the system, rather than focus on a single component External Use 70

72 Closing By now, you should be able to: Create a new Configuration and pick from numerous Stock Scenarios to analyze the system Use the Live Graphs to visualize the Performance Analysis data as it is sampled Utilize the Compare Feature to observe whether or not your performance is improved from one result set to the next Create a new Configuration to profile a specific Linux User Space Application Run a Stock Scenario via the Python Interface Create your own Custom Scenarios External Use 71

73 Closing (continued) Want to download the latest version of the tool? ode=pe_qoriq_opti_suite&fsrch=1&sr=3 Have feedback or user stories to share? Send it to us. Have a Custom Scenario that is a candidate for our default Stock Scenarios? Share it with us via the tools Export feature External Use 72

74 Introducing The QorIQ LS2 Family Breakthrough, software-defined approach to advance the world s new virtualized networks New, high-performance architecture built with ease-of-use in mind Groundbreaking, flexible architecture that abstracts hardware complexity and enables customers to focus their resources on innovation at the application level Optimized for software-defined networking applications Balanced integration of CPU performance with network I/O and C-programmable datapath acceleration that is right-sized (power/performance/cost) to deliver advanced SoC technology for the SDN era Extending the industry s broadest portfolio of 64-bit multicore SoCs Built on the ARM Cortex -A57 architecture with integrated L2 switch enabling interconnect and peripherals to provide a complete system-on-chip solution External Use 73

75 QorIQ LS2 Family Key Features SDN/NFV Switching Data Center Wireless Access Unprecedented performance and ease of use for smarter, more capable networks High performance cores with leading interconnect and memory bandwidth 8x ARM Cortex-A57 cores, 2.0GHz, 4MB L2 cache, w Neon SIMD 1MB L3 platform cache w/ecc 2x 64b DDR4 up to 2.4GT/s A high performance datapath designed with software developers in mind New datapath hardware and abstracted acceleration that is called via standard Linux objects 40 Gbps Packet processing performance with 20Gbps acceleration (crypto, Pattern Match/RegEx, Data Compression) Management complex provides all init/setup/teardown tasks Leading network I/O integration 8x1/10GbE + 8x1G, MACSec on up to 4x 1/10GbE Integrated L2 switching capability for cost savings 4 PCIe Gen3 controllers, 1 with SR-IOV support 2 x SATA 3.0, 2 x USB 3.0 with PHY External Use 74

76 See the LS2 Family First in the Tech Lab! 4 new demos built on QorIQ LS2 processors: Performance Analysis Made Easy Leave the Packet Processing To Us Combining Ease of Use with Performance Tools for Every Step of Your Design External Use 75

77 Freescale Semiconductor, Inc. External Use

78 Backups External Use 77

79 Backups Stack and Heap Modifications Regarding the examples to measure Cache Performance and measure DDR Traffic, the stack and heap for the example applications that are being measured should be modified as follows: _stack_addr = 0x0f3dfff0; _stack_end = 0x073d7ff0; _heap_addr = 0x003cfff0; _heap_end = 0x073d7ff0; Modifications should be made to the application s.lcf file External Use 78

80 Backups C Code Used in Bareboard Cache Performance Examples unsigned long long sumarraynonoptimal (int *array, int w, int h, int n) { unsigned long long ret = 0; int i, x, y; for (i = 0; i < n; i++) for (x = 0; x < w; x++) for (y = 0; y < h; y++) ret += array[y*w + x]; return ret; } unsigned long long sumarrayoptimal (int *array, int w, int h, int n) { unsigned long long ret = 0; int i, x, y; for (i= 0; i< n; i++) for (y = 0; y < h; y++) for (x = 0; x < w; x++) ret += array[y*w + x]; return ret; } External Use 79

81 Backups C Code Used in Bareboard Cache Performance Examples (continued) int main() { int w = 1024; int h = 1024; int a[w*h]; int i; for(i = 0; i < (w*h); i++) a[i] = 5; } i = 0; while(1) i += sumarrayoptimal (a, w, h, 100); External Use 80

82 Backups Python Script measure_cache_performance.py # Import utility module from pfa import pfautils # Import XPCOM support from coremorpho import morpho COMException = morpho.comexception components = morpho.components from ta import cdde, ccs print("measuring with Stock Scenario Data L1 Cache Miss") # Change the address to the tap to be used. The format is etap:ip for an Ethernet Tap, # gtap:jtag:0:ip for an Gigabit Tap connected with the plain JTAG cable and gtap:jtag:1:ip # for an Gigabit Tap connected with the JTAG wires contained in the aurora cable. if not vars().has_key("cc_config"): cc_config = "gtap:jtag:1: " print("using cc_config %s" % cc_config) processor_name = "P5020" # Create the model. It contains in its hierarchy all the supported events and counters. pfa_model = pfautils.load_model(processor_name) External Use 81

83 Backups Python Script measure_cache_performance.py (continued) def get_otf_path(workspace_path): """ Get the full path to the otf file that is to be generated Given the workspace path, this creates a path to the oft file in a folder based on a datetime stamp NOTE: currently Java UI assumes that all collections are named pfa.otf We are retaining that name for now """ import datetime import os name = datetime.datetime.now().strftime("%y_%m_%d_%h_%m_%s") dirpath = workspace_path + "/python_" + name if not os.path.exists(dirpath): os.makedirs(dirpath) return dirpath + "/pfa.otf" External Use 82

84 Backups Python Script measure_cache_performance.py (continued) # Create a configuration based on a stock scenario stockscenario = pfa_model.find( Data L1 Cache Miss") config = stockscenario.create_configuration() # Connect to CDDE. c = cdde.connect() # Get the CDDE peer p = c.peer # default to ccs port if not globals().has_key("ccs_port"): CCS_PORT = # Connect CDDE to the target ccs.connect_ccs(p.conn, processor_name, cc_configuration=cc_config, connectionname="pfa_connection", port=ccs_port) # In this sample we assume that the target application is up and ready. For example it booted via # uboot, or the debugger was used for target initialization and download. # If this did not happen, do this here... # Create the target. target = pfautils.create_target(processor_name) External Use 83

85 Backups Python Script measure_cache_performance.py (continued) # Connect to target using tcf. target.set_tcf(p) p.rc.suspend() # suspend the target # Configure the counters. This will write to core registers # which are only accessible when the target is suspended. target.apply(config) # Resume the target and start the counters. p.rc.resume() target.start_counters() # "Clear" the counters target.capture() # Generate an otf file workspace_path = "C:/dev/scenarioPyWorkspace" otf_filepath = get_otf_path(workspace_path) print("writing samples to Otf file...") print(otf_filepath) otf_writer = pfautils.open_otf_writer(otf_filepath, config) External Use 84

86 Backups Python Script measure_cache_performance.py (continued) # Make some measurements. for i in range(40): from time import sleep; sleep(0.1) otf_writer.add(target.capture()) otf_writer.close() print("sampling finished") # Get the samples that were collected otf_reader = pfautils.read_otf_file(otf_filepath) measurements = otf_reader.measurements # Get the "Results" report object from stockscenario reports = stockscenario.reports for report in reports: if report.name == "Results": results_report = report External Use 85

87 Backups Python Script measure_cache_performance.py (continued) # Print the results report to the report file. # Data is printed as comma-separated values report_file_path = "C:/dev/scenarioPyWorkspace/scenarioReport.out" report_file = open(report_file_path, 'w+') print("printing report to file...") print(report_file_path) results_report.print_report(config, measurements, out=report_file.write) report_file.close() print("done!!!") # When done with the target, cleanup the TCF connection and dispose the protocol p.conn.disconnect("pfa_connection") c.disconnect() External Use 86

88 Freescale Semiconductor, Inc. External Use