# Enabling license logging ##### **Subtopics** - [**Reading log file data**](https://lhc.advantest.com/link/73#bkmrk-reading-log-file-dat-1) - [**Example logfile parser**](https://lhc.advantest.com/link/73#bkmrk-example-logfile-pars) Detailed information about license consumption and optimize license usage can be identified by License usage logging. ### **About this task** To be able to get detailed information about license consumption and optimize license usage, it is necessary to analyze the licensing requirements for memory and speed for each measurement within a test program. From this information, it is then possible to isolate the main license requirements. License usage logging (incremental over measurements and per measurement logging) provides the information required to establish the licensing dependencies. If the watermark increases in proportion to the measurement data, the test is independent, otherwise it shares data with other tests. Log data is written to: `/opt/hp93000/soc/system/log/licenseUsage_.log ` To read in the data you need to generate a parser based on protobuf library using the grammar in: `/opt/hp93000/soc/system/include/xoc/profiling/licenseUsage.proto ` An existing file is not overwritten - only new data is appended to the existing content. The most valuable data collected by license logging is when you have not previously executed an initial bind before executing the profile configuration. After an initial bind, only dynamic changes are recorded. ### **Before you begin**
Make sure the test program has been loaded. License logging can only be enabled using a Profile launch configuration.
### **Procedure**
1. Select a test program or test flow in the **Package Explorer** view for which you want to enable license logging. License logging is not available for encrypted testflows or test programs containing encrypted testflows. 2. Open the **Profile Configurations** dialog from the context menu:
**Profile As > Profile Configurations **
3. Select **Test Program** from the objects pane on the left. 4. Click the New Launch Configuration [![10.png](https://lhc.advantest.com/uploads/images/gallery/2025-10/scaled-1680-/10-png.png)](https://lhc.advantest.com/uploads/images/gallery/2025-10/scaled-1680-/10-png.png) button. 5. Enter a name for the new profile configuration in the configuration pane on the right. 6. In the **Main** tab (default selection), select **Enable license logging**. [![66.png](https://lhc.advantest.com/uploads/images/gallery/2025-10/scaled-1680-/kAy66-png.png)](https://lhc.advantest.com/uploads/images/gallery/2025-10/scaled-1680-/kAy66-png.png) 7. Specify any other required configurations. For details, see [Creating a run configuration for running test programs or testflows](https://tdc.advantest.com/help/topic/com.verigy.itee.help.smartest.ui.8.7.6/256920.htm "You can specify, save and reuse customized configurations for starting test programs or testflows in execute or debug mode."). 8. Click **Apply** to save the profile configuration. 9. Click **Profile** to profile the test flow or **Close** to close the **Profile Configurations** dialog box.
##### **Results** License logging is enabled. Log data is written to `/opt/hp93000/soc/system/log/licenseUsage_.log.` A license usage log file contains the memory contribution (in Bytes) for each signal for each measurement.

Note: License logging can also be enabled and disabled using the Test Cell API. For example: `TestProgramConfig config;` `config.enableLicenseLogging = true;` `testProgram.loadWithConfig(config);` For details about TestProgramConfig, see **[TestProgramConfig](https://tdc.advantest.com/help/topic/com.verigy.itee.help.smartest.ui.8.7.6/structxoc_1_1tcapi_1_1_test_program_config.html).**

##### **What to do next**
The generated log file is user-readable and it is possible to manually extract the licensing requirements for memory and speed for each measurement within a test program. It is not essential to parse this file. However, for further processing, it can be beneficial to parse the file to arrange its content into a more readable format. To read in the data you can generate a parser based on the **protobuf** library using the grammar in: `/opt/hp93000/soc/system/include/xoc/profiling/licenseUsage.proto` --- # Reading log file data 1) Log file data contains information, such as memory usage. ##### **About this task**
If license logging is enabled, the license log data is written to: **`/opt/hp93000/soc/system/log/licenseUsage_.log.`** The following log example shows the used memory (Pattern or PA = 1032 bytes) for the signal D04. The total accumulated value (`accDoubleValue`) is 3096 bytes which the total memory used by the complete program. ##### **LicenseUsage.log file example:** ``` measurementName: "Main.GlobalPAPattern.measurement" measurementTimestamp: "Mon, 01 Jul 2019 15:30:08 -0700" licensedFeatureLog { featurePerSignal { signalList: "D00 + D01 + D02 + D03 + D04" feature { feature: "speed" accDoubleValue: 10000000 unit: "bps" } } featurePerSignal { signalList: "D04" feature { feature: "memory" accDoubleValue: 3096 doubleValue: 1032 unit: "B" } feature { feature: "sharedMemory" doubleValue: 60352 unit: "B" } } } ```
A license usage log file contains the memory contribution (in Bytes) for each signal for each measurement. The accumulated memory value is also recorded. In the example above:
**Measurement**Main.GlobalPAPattern.measurement
**Signal names**signal\_list: "D00 + D01 + D02 + D03 + D04"
**Signal requirement type**feature: speed (all signals) feature: memory (signal D04) feature: sharedMemory (signal D04)
**Accumulated speed value**accDoubleValue: 10000000 bps (all signals)
**Accumulated memory value**acc\_double\_value: 3096 B (signal D04)
**Memory value**doubleValue: 1032 B (signal D04)
**Shared memory value**doubleValue: 60352 B (signal D04)
This file is in the **protobuf** (ASCII) format and can be read using a simple parser. For more information, refer to: https://developers.google.com/protocol-buffers/

Note: If you only require the values for a specific measurement, you can read this from the ASCII text manually.

``` TestProgramConfig config; config.enableLicenseLogging = true; testProgram.loadWithConfig(config); ```
The protocol buffer compiler is installed under `/usr/bin/protoc`The protoc version can be found with the command:`/usr/bin/protoc --version` Output example: **libprotoc 2.5.0** To structure information, protocol buffer message types are defined in .proto files. The following protobuf file is used for license logging, which can be compiled with the protocol buffer compiler to Java, Python, Objective-C, or C++.
---
### **Before you begin**
Make sure that license logging is enabled. For details, see [Enabling license logging](https://lhc.advantest.com/books/flexnet-embedded-licensing/page/enabling-license-logging "Detailed information about license consumption and optimize license usage can be identified by License usage logging.").
### **Procedure**
1. Create a parser file, for an example, see [Example logfile parser](https://lhc.advantest.com/link/73#bkmrk-example-logfile-pars)**.** 2. For example, to compile to C++ with the protocol buffer compiler, run the following commands or a **make.sh** script containing the commands: `protoc -I=/opt/hp93000/soc/system/include/xoc/profiling/ --cpp_out=.` ` /opt/hp93000/soc/system/include/xoc/ profiling/licenseUsage.proto` `c++ -std=c++11 -g -L/usr/local/lib -lprotobuf -o licenseLogger licenseUsage.pb.cc main.cpp` The generated C++ class is used to simplify the parser implementation. ``` ./licenseLogger licenseUsage.log memory D04 Analysing: licenseUsage.log memory D04 Top 20 measurement runs for feature "memory" at signal "D04" Measurement Run | Value |Watermark Value ----------------------------------+----------+----------------------- Main.GlobalPAPattern2.measurement | 1032.000 | 3096.000 ```
### **Results**
After the above **protoc** call or **make.sh** script is run, the following files are created:
**licenseLogger**
Generated Parser Executable To execute the licenseLogger, use the command: `./licenseLogger ` For example: `./licenseLogger licenseUsage.log memory D01`
**measurementLicense.pb.cc**
Generated after running protobuf compiler
**measurementLicense.pb.h**
Generated after running protobuf compiler
--- ## Example logfile parser 1) The following code is an example parser for reading license log files and printing the top 10 measurement executions contributing to the specified feature and signal. #### **Example parser (SmarTest ≥ 8.2.0)** ``` #include #include #include #include #include #include #include #include #include #include "licenseUsage.pb.h" using namespace std; using namespace license; using namespace ::google::protobuf::io; using ::google::protobuf::TextFormat; map featureValuePerMeasurement; map featureValuePerMeasurementWatermark; // measurementName, multimap > licenseUsage; // utility to extract signal from signal list into a vector of signals vector signalsToVector(string& signals) { vector items; const char* t = " \t\n\r\f\v"; unsigned long opos = 0; unsigned long pos = signals.find_first_of(" + "); while (true) { // trim white spaces string extract = signals.substr(opos, pos - opos); extract.erase(0, extract.find_first_not_of(t)); extract.erase(extract.find_last_not_of(t) + 1); items.push_back(extract); if (string::npos == pos) { break; } pos = signals.find_first_of(" + ", opos = pos + 1); } return items; } // Sample method to print Top 20 measurement runs for given feature and signal // In addition print the license usage after the Top1 measurement was executed. void printTop20(string& featureKey, string& sigKey) { int x = 0; int mrlen = 0; for(auto elem = featureValuePerMeasurement.rbegin();elem != featureValuePerMeasurement.rend() && x < 20; ++elem, ++x) { if(elem->second.size() > mrlen) { mrlen = elem->second.size(); } } cout << "Top 20 measurement runs for feature \"" << featureKey << "\" at signal \"" << sigKey << "\"" << endl << endl; cout << setw(mrlen) << left << "Measurement Run" << " | Value | Watermark Value " << endl; for(int i=0;isecond << " | " << setw(12) << left << setprecision(3) << elem->first << " | " << setprecision(3) << featureValuePerMeasurementWatermark[elem->second] << endl; } cout << endl << endl; string mrName = featureValuePerMeasurement.rbegin()->second; auto elements = licenseUsage.equal_range(mrName); auto elem = elements.first; for(;elem != elements.second; ++elem) { cout << "Count: "<< setw(6) << elem->second.second <second.first << endl; } } bool processMessage(string& message, string featureKey, string sigKey) { license::MeasurementLicense log; if (!TextFormat::ParseFromString(message, &log)) { cerr << endl << "Failed to parse string: " << endl; return false; } string mrName = log.measurementname(); LicensedFeatureLog feature = log.licensedfeaturelog(); for(int i=0; i signalVector = signalsToVector(signals); for(int x=0;x 16 && str.substr(0,16).compare("measurementName:") == 0) { if(!processMessage(message, featureKey, sigKey)) { exit(-1); } message = str; continue; } message += str; } printTop20(featureKey, sigKey); } ```