/* Copyright 2020 Achilleas Tzenetopoulos. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ package priorities import ( "encoding/json" "fmt" "strings" _ "github.com/go-sql-driver/mysql" client "github.com/influxdata/influxdb1-client/v2" "k8s.io/klog" ) var ( customResourcePriority = &CustomAllocationPriority{"CustomResourceAllocation", customResourceScorer} //customResourcePriority = &CustomAllocationPriority{"CustomRequestedPriority", customResourceScorer} // LeastRequestedPriorityMap is a priority function that favors nodes with fewer requested resources. // It calculates the percentage of memory and CPU requested by pods scheduled on the node, and // prioritizes based on the minimum of the average of the fraction of requested to capacity. // // Details: // (cpu((capacity-sum(requested))*10/capacity) + memory((capacity-sum(requested))*10/capacity))/2 CustomRequestedPriorityMap = customResourcePriority.PriorityMap ) func customScoreFn(si scorerInput) float64 { return si.metrics["ipc"] / si.metrics["mem_read"] * si.metrics["mem_write"] } func onlyIPC(metrics map[string]float64) float64 { return metrics["ipc"] } func onlyL3(metrics map[string]float64) float64 { return 1 / metrics["l3m"] } func onlyNrg(metrics map[string]float64) float64 { return 1 / metrics["procnrg"] } func calculateScore(si scorerInput, logicFn func(scorerInput) float64) float64 { res := logicFn(si) //klog.Infof("Has score (in float) %v\n", res) return res } func calculateWeightedAverage(response *client.Response, numberOfRows, numberOfMetrics int) (map[string]float64, error) { // initialize the metrics map with a constant size metrics := make(map[string]float64, numberOfMetrics) rows := response.Results[0].Series[0] for i := 1; i < len(rows.Columns); i++ { for j := 0; j < numberOfRows; j++ { val, err := rows.Values[j][i].(json.Number).Float64() if err != nil { klog.Infof("Error while calculating %v", rows.Columns[i]) return nil, err } metrics[rows.Columns[i]] += val * float64(numberOfRows-j) } metrics[rows.Columns[i]] = metrics[rows.Columns[i]] / float64((numberOfRows * (numberOfRows + 1) / 2)) //klog.Infof("%v : %v", rows.Columns[i], metrics[rows.Columns[i]]) } // TODO better handling for the returning errors return metrics, nil } func queryInfluxDB(metrics []string, uuid string, socket, time int, cfg Config, c client.Client) (map[string]float64, error) { // calculate the number of rows needed // i.e. 20sec / 0.5s interval => 40rows numberOfRows := int(float32(time) / cfg.MonitoringSpecs.TimeInterval) // merge all the required columns columns := strings.Join(metrics, ", ") // build the coommand var command strings.Builder fmt.Fprintf(&command, "SELECT %s from socket_metrics where uuid = '%s' and socket_id='%d' order by time desc limit %d", columns, uuid, socket, numberOfRows) q := client.NewQuery(command.String(), cfg.Database.Name, "") response, err := c.Query(q) if err != nil { klog.Infof("Error while executing the query: %v", err.Error()) return nil, err } // Calculate the average for the metrics provided return calculateWeightedAverage(response, numberOfRows, len(metrics)) } func customResourceScorer(nodeName string) (float64, error) { //return (customRequestedScore(requested.MilliCPU, allocable.MilliCPU) + //customRequestedScore(requested.Memory, allocable.Memory)) / 2 //read database information var cfg Config err := readFile(&cfg, "/etc/kubernetes/scheduler-monitoringDB.yaml") if err != nil { return 0, err } /*------------------------------------- //TODO read also nodes to uuid mappings for EVOLVE -------------------------------------*/ // InfluxDB c, err := connectToInfluxDB(cfg) if err != nil { return 0, err } // close the connection in the end of execution defer c.Close() //Get the uuid of this node in order to query in the database curr_uuid, ok := nodes[nodeName] socket, _ := sockets[nodeName] if ok { // Select Socket results, err := queryInfluxDB([]string{"ipc", "mem_read", "mem_write"}, curr_uuid, socket, 20, cfg, c) if err != nil { klog.Infof("Error in querying or calculating average: %v", err.Error()) return 0, nil } res := calculateScore(scorerInput{metrics: results}, customScoreFn) // Select Node klog.Infof("Node name %s, has score %v\n", nodeName, res) return res, nil } else { klog.Infof("Error finding the uuid: %v", ok) return 0, nil } }