Enabling license logging

Subtopics

• Reading log file data
• Example logfile parser

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_<sessionId>.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

Procedure

Results

License logging is enabled.

Log data is written to /opt/hp93000/soc/system/log/licenseUsage_<sessionId>.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.

What to do next

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"
}
}
}

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);

Example logfile parser

¹⁾ 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 <iostream>
#include <fcntl.h>
#include <fstream>
#include <google/protobuf/text_format.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <map>
#include <iostream>
#include <iomanip>
#include <sstream>
#include "licenseUsage.pb.h"
 
using namespace std;
using namespace license;
using namespace ::google::protobuf::io;
using ::google::protobuf::TextFormat;
 
map<double,string> featureValuePerMeasurement;
map<string,double> featureValuePerMeasurementWatermark;
 
//  measurementName, <license string, count>
multimap<string, pair<string,int> > licenseUsage;
 
// utility to extract signal from signal list into a vector of signals
vector<string> signalsToVector(string& signals)
{
 vector<string> 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;i<mrlen;++i) { cout << "-"; }
     cout << "-+--------------+-----------------------" << endl;
     x=0;
     for(auto elem = featureValuePerMeasurement.rbegin();elem != featureValuePerMeasurement.rend() && x < 20; ++elem, ++x) {
     cout << fixed << setw(mrlen) << elem->second << " | " << 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 <<elem->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<feature.featurepersignal_size();++i) {
          FeaturePerSignal fps = feature.featurepersignal(i);
          string signals = fps.signallist();
          vector<string> signalVector = signalsToVector(signals);
          for(int x=0;x<fps.feature_size();++x) {
           Feature f = fps.feature(x);
           if(f.feature() == featureKey) {
            for(auto const & sig : signalVector) {
             if(sig == sigKey) {
              featureValuePerMeasurementWatermark[mrName] = f.accdoublevalue();
              featureValuePerMeasurement[f.doublevalue()] = mrName;
             } 
            }
           }
      }
 }
 
     for(int i=0;i<log.licenses_size();++i) {
     auto l = log.licenses(i);
     for(int x=0; x<l.licensestring_size();++x) {
          auto ls = l.licensestring(x);
          licenseUsage.insert(make_pair(mrName,make_pair(ls.name(), ls.count())));
     }
}
 
 return true;
}            
 
int main(int argc, char** argv)
{
     if (argc != 4) {
          printf("wrong arguments, ussage: licenseLogger featureKey sigKey\n");
          exit (1);
     }
            
     ifstream file(argv[1]);
     string featureKey = string(argv[2]);
     string sigKey = string(argv[3]);
     string str, message;
 
     printf("Analysing: %s %s %s\n", argv[1], argv[2], argv[3]);
 
     getline(file, message);
 
     while (getline(file, str)) {
          if(str.size() > 16 && str.substr(0,16).compare("measurementName:") == 0) {
       if(!processMessage(message, featureKey, sigKey)) { exit(-1); }
       message = str;
       continue;
          }
          message += str;
     }
            
     printTop20(featureKey, sigKey);
}