TrxShell [ mangaberri.com ]

Name	Size	Permission
Install	696 B	-rwxr-xr-x
Remove	677 B	-rwxr-xr-x
pmdamic.python	25.12 KB	-rwxr-xr-x

Code Editor : pmdamic.python

#!/usr/bin/env pmpython
#
# Copyright (c) 2015 Martins Innus.  All Rights Reserved.
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the
# Free Software Foundation; either version 2 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# for more details.
#

'''
Python implementation of an Intel "mic" Performance Metrics Domain Agent.
'''

import sys, os
from ctypes import c_int, c_uint, c_float, c_ulonglong, POINTER, cast, Structure
import cpmapi as c_api
from pcp.pmda import PMDA, pmdaMetric, pmdaIndom, pmdaInstid
from pcp.pmapi import pmUnits, pmContext as PCP

mpss_python_dir = os.environ.get('PMDAMIC_MPSS_PYTHON_DIR')

if mpss_python_dir != None:
    sys.path.insert(1, mpss_python_dir)

from micmgmt import *

class MicDevInfo(Structure):
    ''' Metric values for mic device indom (one per card) '''
# Info
    _fields_ = [("num_cores", c_uint),
                ("num_threads", c_uint),
                ("dev_id", c_uint),
                ("stepping", c_uint),
                ("frequency", c_float),
# Temp
                ("cpu_temp", c_float),
                ("mem_temp", c_float),
                ("fanin_temp", c_float),
                ("fanout_temp", c_float),
                ("core_rail_temp", c_float),
                ("uncore_rail_temp", c_float),
                ("memory_rail_temp", c_float),
# Power
                ("power", c_float),
                ("power_w0", c_float),
                ("power_w1", c_float),
                ("window0", c_float),
                ("window1", c_float),
                ("low_power_limit", c_float),
                ("high_power_limit", c_float),
                ("phys_power_limit", c_float),
# Mem in KB
                ("free_mem", c_ulonglong),
                ("total_mem", c_ulonglong),
                ("used_mem", c_ulonglong),
# Core
                ("tick_count", c_uint),
                ("all_usr", c_ulonglong),
                ("all_sys", c_ulonglong),
                ("all_nice", c_ulonglong),
                ("all_idle", c_ulonglong)]

def __init__(self, cores):
        self.num_cores = cores

class MicPerCoreInfo(Structure):
    ''' Metric values for mic percore indom (one per card/core pair) '''
# Percore
    _fields_ = [ ("cpu_usr", c_ulonglong),
                ("cpu_sys", c_ulonglong),
                ("cpu_nice", c_ulonglong),
                ("cpu_idle", c_ulonglong)]

class MicPMDA(PMDA):
    '''
    A mic Performance Metrics Domain Agent.
    Install it and make basic use of it, as follows:

# $PCP_PMDAS_DIR/mic/Install
    # pminfo -f mic
    '''

# Clusters
    GLOBAL_CLUSTER = 0
    INFO_CLUSTER = 1
    TEMP_CLUSTER = 2
    POWER_CLUSTER = 3
    MEM_CLUSTER = 4
    CORE_CLUSTER = 5
    PERCORE_CLUSTER = 6

# Card indom
    numcards = 0
    cards = {}

# Percore indom
    numcardcores = 0
    cardcores = {}

# As far as I can tell, this is hard coded.
    HZ = 100

def init_mic(self):
        self.numcards = mic_get_ndevices()
        
    def update_mic(self):
        '''
            Update the mic stats. Serial "get" calls don't actually
            refresh unless you call the update functions in between.
        '''
        self.cards.clear()
        self.cardcores.clear()

for device in range(self.numcards):
            mic = MicDevice(device)

mic.mic_update_core_util()
            mic.mic_update_thermal_info()
            mic.mic_update_memory_util()
            mic.mic_update_power_utilization_info()

devinfo = MicDevInfo( mic.mic_get_cores_count() )
            cardname = mic.mic_get_device_name()

# Info / Freq

devinfo.dev_id = mic.mic_get_device_id()
            devinfo.stepping = mic.mic_get_processor_steppingid()
            # Convert from KHz to MHz
            devinfo.frequency = mic.mic_get_cores_frequency() / 1000.0

# Power (Need to check the status for the readings)
            # The readings come in as uWatts but the limits as Watts
            devinfo.power = mic.mic_get_inst_power_readings() / 1000000.0
            if( mic.mic_get_inst_power_sensor_sts() < 0 ):
                devinfo.power = -1

devinfo.power_w0 = mic.mic_get_total_power_readings_w0() / 1000000.0
            if( mic.mic_get_total_power_sensor_sts_w0() < 0 ):
                devinfo.power_w0 = -1

devinfo.power_w1 = mic.mic_get_total_power_readings_w1() / 1000000.0
            if( mic.mic_get_total_power_sensor_sts_w1() < 0 ):
                devinfo.power_w1 = -1

devinfo.window0 = mic.mic_get_time_window0()
            devinfo.window1 = mic.mic_get_time_window1()

devinfo.low_power_limit = mic.mic_get_power_lmrk()
            devinfo.high_power_limit = mic.mic_get_power_hmrk()
            devinfo.phys_power_limit = mic.mic_get_power_phys_limit()

# Temperature (need to check if they are valid after read)
            devinfo.cpu_temp = mic.mic_get_die_temp()
            if( not mic.mic_is_die_temp_valid() ):
                devinfo.cpu_temp = -1
    
            devinfo.mem_temp = mic.mic_get_gddr_temp()
            if( not mic.mic_is_gddr_temp_valid() ):
                devinfo.mem_temp = -1
    
            devinfo.fanin_temp = mic.mic_get_fanin_temp()
            if( not mic.mic_is_fanin_temp_valid() ):
                devinfo.fanin_temp = -1
    
            devinfo.fanout_temp = mic.mic_get_fanout_temp()
            if( not mic.mic_is_fanout_temp_valid() ):
                devinfo.fanout_temp = -1
    
            devinfo.core_rail_temp = mic.mic_get_vccp_temp()
            if( not mic.mic_is_vccp_temp_valid() ):
                devinfo.core_rail_temp = -1
    
            devinfo.uncore_rail_temp = mic.mic_get_vddg_temp()
            if( not mic.mic_is_vddg_temp_valid() ):
                devinfo.uncore_rail_temp = -1
    
            devinfo.memory_rail_temp = mic.mic_get_vddq_temp()
            if( not mic.mic_is_vddq_temp_valid() ):
                devinfo.memory_rail_temp = -1

# Memory, reported in KB
            devinfo.free_mem = mic.mic_get_available_memory_size()
            devinfo.total_mem = mic.mic_get_total_memory_size()
            devinfo.used_mem = devinfo.total_mem - devinfo.free_mem

# Core Metrics
            devinfo.num_threads = mic.mic_get_threads_core()

# All core metrics are converted to ms per thread from jiffies
            millis = devinfo.num_threads * self.HZ

# Overall metrics
            devinfo.all_usr = int(1000 * mic.mic_get_user_sum() / millis)
            devinfo.all_sys = int(1000 * mic.mic_get_sys_sum() / millis)
            devinfo.all_nice = int(1000 * mic.mic_get_nice_sum() / millis)
            devinfo.all_idle = int(1000 * mic.mic_get_idle_sum() / millis)

# Per core metrics
            core_usr = mic.mic_get_user_counters()
            core_sys = mic.mic_get_sys_counters()
            core_nice = mic.mic_get_nice_counters()
            core_idle = mic.mic_get_idle_counters()

cnt = 0
            for usr, sys, nice, idle in zip(core_usr, core_sys, core_nice, core_idle):
                cpuinfo = MicPerCoreInfo()
                cpuinfo.cpu_usr = int(1000 * usr /  millis)
                cpuinfo.cpu_sys = int(1000 * sys / millis)
                cpuinfo.cpu_nice = int(1000 * nice / millis)
                cpuinfo.cpu_idle = int(1000 * idle / millis)

coreinst = "%s/core%d" % (cardname, cnt)

self.cardcores[coreinst] = cpuinfo
                cnt += 1

# Not sure if this is useful but we report it
            devinfo.tick_count = mic.mic_get_tick_count()

self.cards[cardname] = devinfo

self.replace_indom(self.card_indom, self.cards)
        self.replace_indom(self.cardcore_indom, self.cardcores)

def mic_instance(self, serial):
        ''' Called once per "instance request" PDU '''
        # self.log("instance update for %d" % serial)
        self.update_mic()

def mic_fetch(self):
        ''' Called once per "fetch" PDU, before callbacks '''
        self.update_mic()

def mic_fetch_global_callback(self, item, inst):
        '''
        Returns a list of value,status (single pair) for global cluster
        Helper for the fetch callback
        '''
        if (item == 0):
            if (inst != c_api.PM_IN_NULL):
                return [c_api.PM_ERR_INST, 0]
            return [self.numcards, 1]
        else:
            return [c_api.PM_ERR_PMID, 0]

def mic_fetch_info_callback(self, item, inst):
        '''
        Returns a list of value,status (single pair) for info cluster
        Helper for the fetch callback
        '''
        
        voidp = self.inst_lookup(self.card_indom, inst)