Split MetricRouter and MetricAggregator (#24)

* Split MetricRouter and MetricAggregator

* Missing change in MetricCache

* Add README for MetricAggregator

internal/metricAggregator/README.md

@@ -0,0 +1,38 @@
+# The MetricAggregator
+
+In some cases, further combination of metrics or raw values is required. For that strings like `foo + 1` with runtime dependent `foo` need to be evaluated. The MetricAggregator relies on the [`gval`](https://github.com/PaesslerAG/gval) Golang package to perform all expression evaluation. The `gval` package provides the basic arithmetic operations but the MetricAggregator defines additional ones.
+
+**Note**: To get an impression which expressions can be handled by `gval`, see its [README](https://github.com/PaesslerAG/gval/blob/master/README.md)
+
+## Simple expression evaluation
+
+For simple expression evaluation, the MetricAggregator provides two function for different use-cases:
+- `EvalBoolCondition(expression string, params map[string]interface{}`: Used by the MetricRouter to match metrics like `metric.Name() == 'mymetric'`
+- `EvalFloat64Condition(expression string, params map[string]interface{})`: Used by the MetricRouter and LikwidCollector to derive new values like `(PMC0+PMC1)/PMC3`
+
+## MetricAggregator extensions for `gval`
+
+The MetricAggregator provides these functions additional to the `Full` language in `gval`:
+- `sum(array)`: Sum up values in an array like `sum(values)`
+- `min(array)`: Get the minimum value in an array like `min(values)`
+- `avg(array)`: Get the mean value in an array like `avg(values)`
+- `mean(array)`: Get the mean value in an array like `mean(values)`
+- `max(array)`: Get the maximum value in an array like `max(values)`
+- `len(array)`: Get the length of an array like `len(values)`
+- `median(array)`: Get the median value in an array like `mean(values)`
+- `in`: Check existence in an array like `0 in getCpuList()` to check whether there is an entry `0`. Also substring matching works like `temp in metric.Name()`
+- `match`: Regular-expression matching like `match('temp_cores_%d+', metric.Name())`. **Note** all `\` in an regex has to be replaced with `%`
+- `getCpuCore(cpuid)`: For a CPU id, the the corresponding CPU core id like `getCpuCore(0)`
+- `getCpuSocket(cpuid)`: For a CPU id, the the corresponding CPU socket id
+- `getCpuNuma(cpuid)`: For a CPU id, the the corresponding NUMA domain id
+- `getCpuDie(cpuid)`: For a CPU id, the the corresponding CPU die id
+- `getSockCpuList(sockid)`: For a given CPU socket id, the list of CPU ids is returned like the CPUs on socket 1 `getSockCpuList(1)`
+- `getNumaCpuList(numaid)`: For a given NUMA node id, the list of CPU ids is returned
+- `getDieCpuList(dieid)`: For a given CPU die id, the list of CPU ids is returned
+- `getCoreCpuList(coreid)`: For a given CPU core id, the list of CPU ids is returned
+- `getCpuList`: Get the list of all CPUs
+
+## Limitations
+
+- Since the metrics are written in JSON files which do not allow `""` without proper escaping inside of JSON strings, you have to use `''` for strings.
+- Since `\` is interpreted by JSON as escape character, it cannot be used in metrics. But it is required to write regular expressions. So instead of `/`, use `%` and the MetricAggregator replaces them after reading the JSON file.

internal/metricAggregator/metricAggregator.go

@@ -0,0 +1,371 @@
+package metricAggregator
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"os"
+	"strings"
+	"time"
+
+	cclog "github.com/ClusterCockpit/cc-metric-collector/internal/ccLogger"
+
+	lp "github.com/ClusterCockpit/cc-metric-collector/internal/ccMetric"
+	topo "github.com/ClusterCockpit/cc-metric-collector/internal/ccTopology"
+
+	"github.com/PaesslerAG/gval"
+)
+
+type MetricAggregatorIntervalConfig struct {
+	Name      string            `json:"name"`     // Metric name for the new metric
+	Function  string            `json:"function"` // Function to apply on the metric
+	Condition string            `json:"if"`       // Condition for applying function
+	Tags      map[string]string `json:"tags"`     // Tags for the new metric
+	Meta      map[string]string `json:"meta"`     // Meta information for the new metric
+	gvalCond  gval.Evaluable
+	gvalFunc  gval.Evaluable
+}
+
+type metricAggregator struct {
+	functions []*MetricAggregatorIntervalConfig
+	constants map[string]interface{}
+	language  gval.Language
+	output    chan lp.CCMetric
+}
+
+type MetricAggregator interface {
+	AddAggregation(name, function, condition string, tags, meta map[string]string) error
+	DeleteAggregation(name string) error
+	Init(output chan lp.CCMetric) error
+	Eval(starttime time.Time, endtime time.Time, metrics []lp.CCMetric)
+}
+
+var metricCacheLanguage = gval.NewLanguage(
+	gval.Base(),
+	gval.Function("sum", sumfunc),
+	gval.Function("min", minfunc),
+	gval.Function("avg", avgfunc),
+	gval.Function("mean", avgfunc),
+	gval.Function("max", maxfunc),
+	gval.Function("len", lenfunc),
+	gval.Function("median", medianfunc),
+	gval.InfixOperator("in", infunc),
+	gval.Function("match", matchfunc),
+	gval.Function("getCpuCore", getCpuCoreFunc),
+	gval.Function("getCpuSocket", getCpuSocketFunc),
+	gval.Function("getCpuNuma", getCpuNumaDomainFunc),
+	gval.Function("getCpuDie", getCpuDieFunc),
+	gval.Function("getSockCpuList", getCpuListOfSocketFunc),
+	gval.Function("getNumaCpuList", getCpuListOfNumaDomainFunc),
+	gval.Function("getDieCpuList", getCpuListOfDieFunc),
+	gval.Function("getCoreCpuList", getCpuListOfCoreFunc),
+	gval.Function("getCpuList", getCpuListOfNode),
+	gval.Function("getCpuListOfType", getCpuListOfType),
+)
+
+func (c *metricAggregator) Init(output chan lp.CCMetric) error {
+	c.output = output
+	c.functions = make([]*MetricAggregatorIntervalConfig, 0)
+	c.constants = make(map[string]interface{})
+
+	// add constants like hostname, numSockets, ... to constants list
+	// Set hostname
+	hostname, err := os.Hostname()
+	if err != nil {
+		cclog.Error(err.Error())
+		return err
+	}
+	// Drop domain part of host name
+	c.constants["hostname"] = strings.SplitN(hostname, `.`, 2)[0]
+	cinfo := topo.CpuInfo()
+	c.constants["numHWThreads"] = cinfo.NumHWthreads
+	c.constants["numSockets"] = cinfo.NumSockets
+	c.constants["numNumaDomains"] = cinfo.NumNumaDomains
+	c.constants["numDies"] = cinfo.NumDies
+	c.constants["smtWidth"] = cinfo.SMTWidth
+
+	c.language = gval.NewLanguage(
+		gval.Full(),
+		metricCacheLanguage,
+	)
+
+	// Example aggregation function
+	// var f metricCacheFunctionConfig
+	// f.Name = "temp_cores_avg"
+	// //f.Condition = `"temp_core_" in name`
+	// f.Condition = `match("temp_core_%d+", metric.Name())`
+	// f.Function = `avg(values)`
+	// f.Tags = map[string]string{"type": "node"}
+	// f.Meta = map[string]string{"group": "IPMI", "unit": "degC", "source": "TempCollector"}
+	// c.functions = append(c.functions, &f)
+	return nil
+}
+
+func (c *metricAggregator) Eval(starttime time.Time, endtime time.Time, metrics []lp.CCMetric) {
+	vars := make(map[string]interface{})
+	for k, v := range c.constants {
+		vars[k] = v
+	}
+	vars["starttime"] = starttime
+	vars["endtime"] = endtime
+	for _, f := range c.functions {
+		cclog.ComponentDebug("MetricCache", "COLLECT", f.Name, "COND", f.Condition)
+		values := make([]float64, 0)
+		matches := make([]lp.CCMetric, 0)
+		for _, m := range metrics {
+			vars["metric"] = m
+			//value, err := gval.Evaluate(f.Condition, vars, c.language)
+			value, err := f.gvalCond.EvalBool(context.Background(), vars)
+			if err != nil {
+				cclog.ComponentError("MetricCache", "COLLECT", f.Name, "COND", f.Condition, ":", err.Error())
+				continue
+			}
+			if value {
+				v, valid := m.GetField("value")
+				if valid {
+					switch x := v.(type) {
+					case float64:
+						values = append(values, x)
+					case float32:
+					case int:
+					case int64:
+						values = append(values, float64(x))
+					case bool:
+						if x {
+							values = append(values, float64(1.0))
+						} else {
+							values = append(values, float64(0.0))
+						}
+					default:
+						cclog.ComponentError("MetricCache", "COLLECT ADD VALUE", v, "FAILED")
+					}
+				}
+				matches = append(matches, m)
+			}
+		}
+		delete(vars, "metric")
+		cclog.ComponentDebug("MetricCache", "EVALUATE", f.Name, "METRICS", len(values), "CALC", f.Function)
+		vars["values"] = values
+		vars["metrics"] = matches
+		if len(values) > 0 {
+			value, err := gval.Evaluate(f.Function, vars, c.language)
+			if err != nil {
+				cclog.ComponentError("MetricCache", "EVALUATE", f.Name, "METRICS", len(values), "CALC", f.Function, ":", err.Error())
+				break
+			}
+
+			copy_tags := func(tags map[string]string, metrics []lp.CCMetric) map[string]string {
+				out := make(map[string]string)
+				for key, value := range tags {
+					switch value {
+					case "<copy>":
+						for _, m := range metrics {
+							v, err := m.GetTag(key)
+							if err {
+								out[key] = v
+							}
+						}
+					default:
+						out[key] = value
+					}
+				}
+				return out
+			}
+			copy_meta := func(meta map[string]string, metrics []lp.CCMetric) map[string]string {
+				out := make(map[string]string)
+				for key, value := range meta {
+					switch value {
+					case "<copy>":
+						for _, m := range metrics {
+							v, err := m.GetMeta(key)
+							if err {
+								out[key] = v
+							}
+						}
+					default:
+						out[key] = value
+					}
+				}
+				return out
+			}
+			tags := copy_tags(f.Tags, matches)
+			meta := copy_meta(f.Meta, matches)
+
+			var m lp.CCMetric
+			switch t := value.(type) {
+			case float64:
+				m, err = lp.New(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime)
+			case float32:
+				m, err = lp.New(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime)
+			case int:
+				m, err = lp.New(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime)
+			case int64:
+				m, err = lp.New(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime)
+			case string:
+				m, err = lp.New(f.Name, tags, meta, map[string]interface{}{"value": t}, starttime)
+			default:
+				cclog.ComponentError("MetricCache", "Gval returned invalid type", t, "skipping metric", f.Name)
+			}
+			if err != nil {
+				cclog.ComponentError("MetricCache", "Cannot create metric from Gval result", value, ":", err.Error())
+			}
+			cclog.ComponentDebug("MetricCache", "SEND", m)
+			select {
+			case c.output <- m:
+			default:
+			}
+
+		}
+	}
+}
+
+func (c *metricAggregator) AddAggregation(name, function, condition string, tags, meta map[string]string) error {
+	// Since "" cannot be used inside of JSON strings, we use '' and replace them here because gval does not like ''
+	// but wants ""
+	newfunc := strings.ReplaceAll(function, "'", "\"")
+	newcond := strings.ReplaceAll(condition, "'", "\"")
+	gvalCond, err := gval.Full(metricCacheLanguage).NewEvaluable(newcond)
+	if err != nil {
+		cclog.ComponentError("MetricAggregator", "Cannot add aggregation, invalid if condition", newcond, ":", err.Error())
+		return err
+	}
+	gvalFunc, err := gval.Full(metricCacheLanguage).NewEvaluable(newfunc)
+	if err != nil {
+		cclog.ComponentError("MetricAggregator", "Cannot add aggregation, invalid function condition", newfunc, ":", err.Error())
+		return err
+	}
+	for _, agg := range c.functions {
+		if agg.Name == name {
+			agg.Name = name
+			agg.Condition = newcond
+			agg.Function = newfunc
+			agg.Tags = tags
+			agg.Meta = meta
+			agg.gvalCond = gvalCond
+			agg.gvalFunc = gvalFunc
+			return nil
+		}
+	}
+	var agg MetricAggregatorIntervalConfig
+	agg.Name = name
+	agg.Condition = newcond
+	agg.gvalCond = gvalCond
+	agg.Function = newfunc
+	agg.gvalFunc = gvalFunc
+	agg.Tags = tags
+	agg.Meta = meta
+	c.functions = append(c.functions, &agg)
+	return nil
+}
+
+func (c *metricAggregator) DeleteAggregation(name string) error {
+	for i, agg := range c.functions {
+		if agg.Name == name {
+			copy(c.functions[i:], c.functions[i+1:])
+			c.functions[len(c.functions)-1] = nil
+			c.functions = c.functions[:len(c.functions)-1]
+			return nil
+		}
+	}
+	return fmt.Errorf("no aggregation for metric name %s", name)
+}
+
+func (c *metricAggregator) AddConstant(name string, value interface{}) {
+	c.constants[name] = value
+}
+
+func (c *metricAggregator) DelConstant(name string) {
+	delete(c.constants, name)
+}
+
+func (c *metricAggregator) AddFunction(name string, function func(args ...interface{}) (interface{}, error)) {
+	c.language = gval.NewLanguage(c.language, gval.Function(name, function))
+}
+
+func EvalBoolCondition(condition string, params map[string]interface{}) (bool, error) {
+	newcond := strings.ReplaceAll(condition, "'", "\"")
+	newcond = strings.ReplaceAll(newcond, "%", "\\")
+	language := gval.NewLanguage(
+		gval.Full(),
+		metricCacheLanguage,
+	)
+	value, err := gval.Evaluate(newcond, params, language)
+	if err != nil {
+		return false, err
+	}
+	var endResult bool = false
+	err = nil
+	switch r := value.(type) {
+	case bool:
+		endResult = r
+	case float64:
+		if r != 0.0 {
+			endResult = true
+		}
+	case float32:
+		if r != 0.0 {
+			endResult = true
+		}
+	case int:
+		if r != 0 {
+			endResult = true
+		}
+	case int64:
+		if r != 0 {
+			endResult = true
+		}
+	case int32:
+		if r != 0 {
+			endResult = true
+		}
+	default:
+		err = fmt.Errorf("cannot evaluate '%s' to bool", newcond)
+	}
+	return endResult, err
+}
+
+func EvalFloat64Condition(condition string, params map[string]interface{}) (float64, error) {
+	var endResult float64 = math.NaN()
+	newcond := strings.ReplaceAll(condition, "'", "\"")
+	newcond = strings.ReplaceAll(newcond, "%", "\\")
+	language := gval.NewLanguage(
+		gval.Full(),
+		metricCacheLanguage,
+	)
+	value, err := gval.Evaluate(newcond, params, language)
+	if err != nil {
+		cclog.ComponentDebug("MetricRouter", condition, " = ", err.Error())
+		return endResult, err
+	}
+	err = nil
+	switch r := value.(type) {
+	case bool:
+		if r {
+			endResult = 1.0
+		} else {
+			endResult = 0.0
+		}
+	case float64:
+		endResult = r
+	case float32:
+		endResult = float64(r)
+	case int:
+		endResult = float64(r)
+	case int64:
+		endResult = float64(r)
+	case int32:
+		endResult = float64(r)
+	default:
+		err = fmt.Errorf("cannot evaluate '%s' to float64", newcond)
+	}
+	return endResult, err
+}
+
+func NewAggregator(output chan lp.CCMetric) (MetricAggregator, error) {
+	a := new(metricAggregator)
+	err := a.Init(output)
+	if err != nil {
+		return nil, err
+	}
+	return a, err
+}

internal/metricAggregator/metricAggregatorFunctions.go

@@ -0,0 +1,376 @@
+package metricAggregator
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"regexp"
+	"sort"
+	"strings"
+
+	cclog "github.com/ClusterCockpit/cc-metric-collector/internal/ccLogger"
+	topo "github.com/ClusterCockpit/cc-metric-collector/internal/ccTopology"
+)
+
+/*
+ * Arithmetic functions on value arrays
+ */
+
+// Sum up values
+func sumfunc(args ...interface{}) (interface{}, error) {
+	s := 0.0
+	values, ok := args[0].([]float64)
+	if ok {
+		cclog.ComponentDebug("MetricCache", "SUM FUNC START")
+		for _, x := range values {
+			s += x
+		}
+		cclog.ComponentDebug("MetricCache", "SUM FUNC END", s)
+	} else {
+		cclog.ComponentDebug("MetricCache", "SUM FUNC CAST FAILED")
+	}
+	return s, nil
+}
+
+// Get the minimum value
+func minfunc(args ...interface{}) (interface{}, error) {
+	var err error = nil
+	switch values := args[0].(type) {
+	case []float64:
+		var s float64 = math.MaxFloat64
+		for _, x := range values {
+			if x < s {
+				s = x
+			}
+		}
+		return s, nil
+	case []float32:
+		var s float32 = math.MaxFloat32
+		for _, x := range values {
+			if x < s {
+				s = x
+			}
+		}
+		return s, nil
+	case []int:
+		var s int = int(math.MaxInt32)
+		for _, x := range values {
+			if x < s {
+				s = x
+			}
+		}
+		return s, nil
+	case []int64:
+		var s int64 = math.MaxInt64
+		for _, x := range values {
+			if x < s {
+				s = x
+			}
+		}
+		return s, nil
+	case []int32:
+		var s int32 = math.MaxInt32
+		for _, x := range values {
+			if x < s {
+				s = x
+			}
+		}
+		return s, nil
+	default:
+		err = errors.New("function 'min' only on list of values (float64, float32, int, int32, int64)")
+	}
+
+	return 0.0, err
+}
+
+// Get the average or mean value
+func avgfunc(args ...interface{}) (interface{}, error) {
+	switch values := args[0].(type) {
+	case []float64:
+		var s float64 = 0
+		for _, x := range values {
+			s += x
+		}
+		return s / float64(len(values)), nil
+	case []float32:
+		var s float32 = 0
+		for _, x := range values {
+			s += x
+		}
+		return s / float32(len(values)), nil
+	case []int:
+		var s int = 0
+		for _, x := range values {
+			s += x
+		}
+		return s / len(values), nil
+	case []int64:
+		var s int64 = 0
+		for _, x := range values {
+			s += x
+		}
+		return s / int64(len(values)), nil
+	}
+	return 0.0, nil
+}
+
+// Get the maximum value
+func maxfunc(args ...interface{}) (interface{}, error) {
+	s := 0.0
+	values, ok := args[0].([]float64)
+	if ok {
+		for _, x := range values {
+			if x > s {
+				s = x
+			}
+		}
+	}
+	return s, nil
+}
+
+// Get the median value
+func medianfunc(args ...interface{}) (interface{}, error) {
+	switch values := args[0].(type) {
+	case []float64:
+		sort.Float64s(values)
+		return values[len(values)/2], nil
+	// case []float32:
+	// 	sort.Float64s(values)
+	// 	return values[len(values)/2], nil
+	case []int:
+		sort.Ints(values)
+		return values[len(values)/2], nil
+
+		// case []int64:
+		// 	sort.Ints(values)
+		// 	return values[len(values)/2], nil
+		// case []int32:
+		// 	sort.Ints(values)
+		// 	return values[len(values)/2], nil
+	}
+	return 0.0, errors.New("function 'median()' only on lists of type float64 and int")
+}
+
+/*
+ * Get number of values in list. Returns always an int
+ */
+
+func lenfunc(args ...interface{}) (interface{}, error) {
+	var err error = nil
+	var length int = 0
+	switch values := args[0].(type) {
+	case []float64:
+		length = len(values)
+	case []float32:
+		length = len(values)
+	case []int:
+		length = len(values)
+	case []int64:
+		length = len(values)
+	case []int32:
+		length = len(values)
+	case float64:
+		err = errors.New("function 'len' can only be applied on arrays and strings")
+	case float32:
+		err = errors.New("function 'len' can only be applied on arrays and strings")
+	case int:
+		err = errors.New("function 'len' can only be applied on arrays and strings")
+	case int64:
+		err = errors.New("function 'len' can only be applied on arrays and strings")
+	case string:
+		length = len(values)
+	}
+	return length, err
+}
+
+/*
+ * Check if a values is in a list
+ * In constrast to most of the other functions, this one is an infix operator for
+ * - substring matching: `"abc" in "abcdef"` -> true
+ * - substring matching with int casting: `3 in "abd3"` -> true
+ * - search for an int in an int list: `3 in getCpuList()` -> true (if you have more than 4 CPU hardware threads)
+ */
+
+func infunc(a interface{}, b interface{}) (interface{}, error) {
+	switch match := a.(type) {
+	case string:
+		switch total := b.(type) {
+		case string:
+			return strings.Contains(total, match), nil
+		}
+	case int:
+		switch total := b.(type) {
+		case []int:
+			for _, x := range total {
+				if x == match {
+					return true, nil
+				}
+			}
+		case string:
+			smatch := fmt.Sprintf("%d", match)
+			return strings.Contains(total, smatch), nil
+		}
+
+	}
+	return false, nil
+}
+
+/*
+ * Regex matching of strings (metric name, tag keys, tag values, meta keys, meta values)
+ * Since we cannot use \ inside JSON strings without escaping, we use % instead for the
+ * format keys \d = %d, \w = %d, ... Not sure how to fix this
+ */
+
+func matchfunc(args ...interface{}) (interface{}, error) {
+	switch match := args[0].(type) {
+	case string:
+		switch total := args[1].(type) {
+		case string:
+			smatch := strings.Replace(match, "%", "\\", -1)
+			regex, err := regexp.Compile(smatch)
+			if err != nil {
+				return false, err
+			}
+			s := regex.Find([]byte(total))
+			return s != nil, nil
+		}
+	}
+	return false, nil
+}
+
+/*
+ * System topology getter functions
+ */
+
+// for a given cpuid, it returns the core id
+func getCpuCoreFunc(args ...interface{}) (interface{}, error) {
+	switch cpuid := args[0].(type) {
+	case int:
+		return topo.GetCpuCore(cpuid), nil
+	}
+	return -1, errors.New("function 'getCpuCore' accepts only an 'int' cpuid")
+}
+
+// for a given cpuid, it returns the socket id
+func getCpuSocketFunc(args ...interface{}) (interface{}, error) {
+	switch cpuid := args[0].(type) {
+	case int:
+		return topo.GetCpuSocket(cpuid), nil
+	}
+	return -1, errors.New("function 'getCpuCore' accepts only an 'int' cpuid")
+}
+
+// for a given cpuid, it returns the id of the NUMA node
+func getCpuNumaDomainFunc(args ...interface{}) (interface{}, error) {
+	switch cpuid := args[0].(type) {
+	case int:
+		return topo.GetCpuNumaDomain(cpuid), nil
+	}
+	return -1, errors.New("function 'getCpuNuma' accepts only an 'int' cpuid")
+}
+
+// for a given cpuid, it returns the id of the CPU die
+func getCpuDieFunc(args ...interface{}) (interface{}, error) {
+	switch cpuid := args[0].(type) {
+	case int:
+		return topo.GetCpuDie(cpuid), nil
+	}
+	return -1, errors.New("function 'getCpuDie' accepts only an 'int' cpuid")
+}
+
+// for a given core id, it returns the list of cpuids
+func getCpuListOfCoreFunc(args ...interface{}) (interface{}, error) {
+	cpulist := make([]int, 0)
+	switch in := args[0].(type) {
+	case int:
+		for _, c := range topo.CpuData() {
+			if c.Core == in {
+				cpulist = append(cpulist, c.Cpuid)
+			}
+		}
+	}
+	return cpulist, nil
+}
+
+// for a given socket id, it returns the list of cpuids
+func getCpuListOfSocketFunc(args ...interface{}) (interface{}, error) {
+	cpulist := make([]int, 0)
+	switch in := args[0].(type) {
+	case int:
+		for _, c := range topo.CpuData() {
+			if c.Socket == in {
+				cpulist = append(cpulist, c.Cpuid)
+			}
+		}
+	}
+	return cpulist, nil
+}
+
+// for a given id of a NUMA domain, it returns the list of cpuids
+func getCpuListOfNumaDomainFunc(args ...interface{}) (interface{}, error) {
+	cpulist := make([]int, 0)
+	switch in := args[0].(type) {
+	case int:
+		for _, c := range topo.CpuData() {
+			if c.Numadomain == in {
+				cpulist = append(cpulist, c.Cpuid)
+			}
+		}
+	}
+	return cpulist, nil
+}
+
+// for a given CPU die id, it returns the list of cpuids
+func getCpuListOfDieFunc(args ...interface{}) (interface{}, error) {
+	cpulist := make([]int, 0)
+	switch in := args[0].(type) {
+	case int:
+		for _, c := range topo.CpuData() {
+			if c.Die == in {
+				cpulist = append(cpulist, c.Cpuid)
+			}
+		}
+	}
+	return cpulist, nil
+}
+
+// wrapper function to get a list of all cpuids of the node
+func getCpuListOfNode(args ...interface{}) (interface{}, error) {
+	return topo.CpuList(), nil
+}
+
+// helper function to get the cpuid list for a CCMetric type tag set (type and type-id)
+// since there is no access to the metric data in the function, is should be called like
+// `getCpuListOfType()`
+func getCpuListOfType(args ...interface{}) (interface{}, error) {
+	cpulist := make([]int, 0)
+	switch typ := args[0].(type) {
+	case string:
+		switch typ {
+		case "node":
+			return topo.CpuList(), nil
+		case "socket":
+			return getCpuListOfSocketFunc(args[1])
+		case "numadomain":
+			return getCpuListOfNumaDomainFunc(args[1])
+		case "core":
+			return getCpuListOfCoreFunc(args[1])
+		case "cpu":
+			var cpu int
+
+			switch id := args[1].(type) {
+			case string:
+				_, err := fmt.Scanf(id, "%d", &cpu)
+				if err == nil {
+					cpulist = append(cpulist, cpu)
+				}
+			case int:
+				cpulist = append(cpulist, id)
+			case int64:
+				cpulist = append(cpulist, int(id))
+			}
+
+		}
+	}
+	return cpulist, errors.New("no valid args type and type-id")
+}