blob: 6b014e47aa8496972af0ed9c77ae062b8556e97e [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
// //
// Copyright (c) 2000-2019 Ericsson Telecom AB //
// //
// All rights reserved. This program and the accompanying materials //
// are made available under the terms of the Eclipse Public License v2.0 //
// which accompanies this distribution, and is available at //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Module: EPTF_CLL_HostAdmin_BaseFunctions
//
// Purpose:
// This module contains function definitions for EPTF HostAdmin Base
//
// Module Parameters:
// tsp_debug_EPTF_HostAdmin_Base_Functions - *boolean* - debug messages on/off
// tsp_debug_EPTF_HostAdmin_Base_Functions_smoothing - *boolean* - debug messages of smoothing on/off
// tsp_EPTF_HostAdmin_loadMeasurementExponentialSmoothingFactor - *float* - smoothing
// factor used for smoothing. Its value should be between 0.0 and 1.0
// tsp_EPTF_HostAdmin_loadMeasurementRefreshTime - *float* - define the periodical refresh time
//
// Module depends on:
// <EPTF_CLL_HostAdmin_BaseDefinitions>
// <LOADMEASasp_PortType>
// <EPTF_CLL_Base_Functions>
// <EPTF_CLL_Common_Functions>
//
// Current Owner:
// Gabor Tatarka (egbotat)
// Bence Molnar (ebenmol)
//
// Last Review Date:
// 2008-02-14
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
module EPTF_CLL_HostAdmin_BaseFunctions
{
//=========================================================================
// Imports
//=======================================================================
import from EPTF_CLL_HostAdmin_BaseDefinitions all;
import from LOADMEASasp_PortType all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Common_Functions all;
modulepar boolean tsp_debug_EPTF_HostAdmin_Base_Functions := false;
modulepar boolean tsp_debug_EPTF_HostAdmin_Base_Functions_smoothing := false;
modulepar float tsp_EPTF_HostAdmin_loadMeasurementExponentialSmoothingFactor := 0.5; // should be between 0.0:extreme smoothing and 1,0:no smoothing
modulepar float tsp_EPTF_HostAdmin_loadMeasurementRefreshTime := 1.0; // default 1 secs
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_init_CT
//
// Purpose:
// Load measurement interface initialisation for EPTF_HostAdmin_Base_CT
//
// Parameters:
// pl_selfName - *charstring* - EPTF self name
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// Also initializes constant measurement data: number of CPUs and physical memory size.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_init_CT(in charstring pl_selfName) runs on EPTF_HostAdmin_Base_CT
{
if(tsp_debug_EPTF_HostAdmin_Base_Functions and v_EPTF_HostAdmin_Base_initialized) {
f_EPTF_Common_user(%definitionId&": already initialized.");
}
if(tsp_debug_EPTF_HostAdmin_Base_Functions) { f_EPTF_Common_user("f_EPTF_HostAdmin_Base_initCT(): started"); }
map(self:v_EPTF_HostAdmin_CPUloadOnHost_PCO, system:v_EPTF_HostAdmin_CPUloadOnHost_PCO);
f_EPTF_Base_init_CT(pl_selfName);
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := CPU, msg := { startMeas := {} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := CPU, msg := { setPeriod := {periodTime := tsp_EPTF_HostAdmin_loadMeasurementRefreshTime} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := MEMORY, msg := { startMeas := {} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := MEMORY, msg := { setPeriod := {periodTime := tsp_EPTF_HostAdmin_loadMeasurementRefreshTime} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
v_EPTF_HostAdmin_numCPUs := getNumCPUs(v_EPTF_HostAdmin_CPUloadOnHost_PCO);
for(var integer i:=0; i<v_EPTF_HostAdmin_numCPUs; i:=i+1) { v_EPTF_HostAdmin_CPULoads[i] := 0.0; }
v_EPTF_HostAdmin_physicalMemory := getPhysicalMemory(v_EPTF_HostAdmin_CPUloadOnHost_PCO);
v_EPTF_HostAdmin_Base_initialized := true;
f_EPTF_Base_registerCleanup(refers(f_EPTF_HostAdmin_Base_cleanup_CT));
if(tsp_debug_EPTF_HostAdmin_Base_Functions) { f_EPTF_Common_user("f_EPTF_HostAdmin_Base_initCT(): finished"); }
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getNumCPUs
//
// Purpose:
// Returns the number of CPUs
//
// Parameters:
// -
//
// Return Value:
// integer - the number of CPUs
//
// Errors:
// -
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getNumCPUs() runs on EPTF_HostAdmin_Base_CT return integer {
return v_EPTF_HostAdmin_numCPUs;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getPhysicalMemory
//
// Purpose:
// Returns the physical memory
//
// Parameters:
// -
//
// Return Value:
// integer - the physical memory
//
// Errors:
// -
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getPhysicalMemory() runs on EPTF_HostAdmin_Base_CT return integer {
return v_EPTF_HostAdmin_physicalMemory;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getTesterHostLoad
//
// Purpose:
// Returns the load on the tester host
//
// Parameters:
// -
//
// Return Value:
// float - the load on the tester host
//
// Errors:
// -
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getTesterHostLoad() runs on EPTF_HostAdmin_Base_CT return float {
return v_EPTF_HostAdmin_testerHostLoad;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getFreeMemory
//
// Purpose:
// Returns the free memory
//
// Parameters:
// -
//
// Return Value:
// integer - the free memory
//
// Errors:
// -
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getFreeMemory() runs on EPTF_HostAdmin_Base_CT return integer {
return v_EPTF_HostAdmin_freeMemory;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getCPULoads
//
// Purpose:
// Returns the load on the given CPU
//
// Parameters:
// pl_idx - *in integer* - the index of the CPU
//
// Return Value:
// float - the load on the given CPU
//
// Errors:
// -
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getCPULoads(in integer pl_idx) runs on EPTF_HostAdmin_Base_CT return float {
if(pl_idx < sizeof(v_EPTF_HostAdmin_CPULoads) and pl_idx >= 0) {
return v_EPTF_HostAdmin_CPULoads[pl_idx];
} else {
return 0.0;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getProcessName
//
// Purpose:
// Function for getting the name of a process by its pid
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *charstring*
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getProcessName(in integer pl_pid)
runs on EPTF_HostAdmin_Base_CT
return charstring
{
return getProcessName(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_pid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_addProcessStat
//
// Purpose:
// Function for adding statistics for a process by its pid
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *integer* - index
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_addProcessStat(in integer pl_pid)
runs on EPTF_HostAdmin_Base_CT
return integer
{
return addProcessStat(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_pid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_removeProcessStat
//
// Purpose:
// Function for removing statistics for a process by its pid
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_removeProcessStat(in integer pl_pid)
runs on EPTF_HostAdmin_Base_CT
{
removeProcessStat(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_pid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_removeProcessStatByIdx
//
// Purpose:
// Function for removing statistics for a process by its index
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// -
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_removeProcessStatByIdx(in integer pl_idx)
runs on EPTF_HostAdmin_Base_CT
{
removeProcessStatByIdx(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_idx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getProcessCpuLoad
//
// Purpose:
// Function for getting the CPU load of a previously added process by its pid
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *float* - the CPU load in percentage (similar to `top`)
//
// Detailed Comments:
// The process must be added with addProcessStat first.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getProcessCpuLoad(in integer pl_pid)
runs on EPTF_HostAdmin_Base_CT
return float
{
return getProcessCpuLoad(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_pid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getProcessCpuLoadByIdx
//
// Purpose:
// Function for getting the CPU load of a previously added process by its index
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *float* - the CPU load in percentage (similar to `top`)
//
// Detailed Comments:
// The process must be added with addProcessStat first.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getProcessCpuLoadByIdx(in integer pl_idx)
runs on EPTF_HostAdmin_Base_CT
return float
{
return getProcessCpuLoadByIdx(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_idx);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getProcessMemUsage
//
// Purpose:
// Function for getting the memory usage of a previously added process by its pid
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *integer* - memory usage of the process in kB
//
// Detailed Comments:
// The process must be added with addProcessStat first.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getProcessMemUsage(in integer pl_pid)
runs on EPTF_HostAdmin_Base_CT
return integer
{
return getProcessMemUsage(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_pid);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_getProcessMemUsageByIdx
//
// Purpose:
// Function for getting the memory usage of a previously added process by its index
//
// Parameters:
// pl_pid - *integer* - process id
//
// Return Value:
// *integer* - memory usage of the process in kB
//
// Detailed Comments:
// The process must be added with addProcessStat first.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_getProcessMemUsageByIdx(in integer pl_idx)
runs on EPTF_HostAdmin_Base_CT
return integer
{
return getProcessMemUsageByIdx(v_EPTF_HostAdmin_CPUloadOnHost_PCO, pl_idx);
}
group Private {
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_cleanup_CT
//
// Purpose:
// Load measurement interface cleanup for EPTF_HostAdmin_Base_CT
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// Private function, call f_EPTF_Base_cleanup_CT to perform cleanup.
///////////////////////////////////////////////////////////
private function f_EPTF_HostAdmin_Base_cleanup_CT() runs on EPTF_HostAdmin_Base_CT
{
if(tsp_debug_EPTF_HostAdmin_Base_Functions) { f_EPTF_Common_user(%definitionId&": started"); }
if(not v_EPTF_HostAdmin_Base_initialized) {
f_EPTF_Common_warning(%definitionId&": not initialized.");
}
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := CPU, msg := { stopMeas := {} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
v_EPTF_HostAdmin_ASP_LOADMEAS := { loadType := MEMORY, msg := { stopMeas := {} } };
v_EPTF_HostAdmin_CPUloadOnHost_PCO.send(v_EPTF_HostAdmin_ASP_LOADMEAS);
unmap(self:v_EPTF_HostAdmin_CPUloadOnHost_PCO, system:v_EPTF_HostAdmin_CPUloadOnHost_PCO);
v_EPTF_HostAdmin_testerHostLoad := 0.0;
v_EPTF_HostAdmin_numCPUs := 0;
v_EPTF_HostAdmin_CPULoads := {};
v_EPTF_HostAdmin_physicalMemory := 0;
v_EPTF_HostAdmin_freeMemory := 0;
v_EPTF_HostAdmin_Base_initialized := false;
if(tsp_debug_EPTF_HostAdmin_Base_Functions) { f_EPTF_Common_user(%definitionId&": finished"); }
}
} // group Private
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_Base_update
//
// Purpose:
// Updates measurement variables from the testport.
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// At least one second has to elapse between successive calls to this function.
///////////////////////////////////////////////////////////
public function f_EPTF_HostAdmin_Base_update() runs on EPTF_HostAdmin_Base_CT
{
v_EPTF_HostAdmin_testerHostLoad := f_EPTF_HostAdmin_exponentialSmoothingFunction(getCPULoadAvg(v_EPTF_HostAdmin_CPUloadOnHost_PCO),
v_EPTF_HostAdmin_testerHostLoad, tsp_EPTF_HostAdmin_loadMeasurementExponentialSmoothingFactor);
for(var integer i:=0; i<v_EPTF_HostAdmin_numCPUs; i:=i+1) {
v_EPTF_HostAdmin_CPULoads[i] := f_EPTF_HostAdmin_exponentialSmoothingFunction(getCPULoad(v_EPTF_HostAdmin_CPUloadOnHost_PCO, i),
v_EPTF_HostAdmin_CPULoads[i], tsp_EPTF_HostAdmin_loadMeasurementExponentialSmoothingFactor);
}
v_EPTF_HostAdmin_freeMemory := getFreeMemory(v_EPTF_HostAdmin_CPUloadOnHost_PCO);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_HostAdmin_exponentialSmoothingFunction
//
// Purpose:
// This function is used to smooth the measured load using exponential smoothing
//
// Parameters:
// pl_measuredLoad - *in* *float* - value of the currently measured load
//
// pl_prevLoad - *in* *float* - value of the previous smoothed load
//
// pl_smoothingFactor - *in* *float* - smoothing factor, should be between
// 0.0 (extreme smoothing) and 1.0 (no smoothing)
//
// Return Value:
// float - smoothed load
//
// Errors:
// -
//
// Detailed Comments:
// This function can be used to remove high fluctuations of the measured data.
// The function uses exponetial smoothing, which is based on the following formula:
//
// s_0 = x_0
//
// s_t = alpha * x_t + (1-alpha) * s_(t-1)
//
// x_t is the measured data at t iteration, s_t is the smoothed value
//
///////////////////////////////////////////////////////////
private function f_EPTF_HostAdmin_exponentialSmoothingFunction(in float pl_measuredLoad, in float pl_prevLoad, in float pl_smoothingFactor)
return float
{
if(tsp_debug_EPTF_HostAdmin_Base_Functions_smoothing) { f_EPTF_Common_user(log2str("f_EPTF_exponentialSmoothingFunction: measured load: " & float2str(pl_measuredLoad))); }
var float vl_currLoad := pl_smoothingFactor*pl_measuredLoad+(1.0-pl_smoothingFactor)*pl_prevLoad;
if(tsp_debug_EPTF_HostAdmin_Base_Functions_smoothing) { f_EPTF_Common_user(log2str("f_EPTF_exponentialSmoothingFunction: smoothed load: " & float2str(vl_currLoad))); }
return vl_currLoad;
}
} // module