[YUNIKORN-2089] Moved usedResource type and tests to their own files (apache#713)

Closes: apache#713

Signed-off-by: Peter Bacsko <[email protected]>

Author: vinayakphegde

pkg/common/resources/resources.go

@@ -25,8 +25,6 @@ import (
 	"sort"
 	"strconv"
 	"strings"
-	"sync"
-	"time"
 
 	"go.uber.org/zap"
 
@@ -46,58 +44,6 @@ func (q Quantity) string() string {
 	return strconv.FormatInt(int64(q), 10)
 }
 
-// Util struct to keep track of application resource usage
-type TrackedResource struct {
-	// Two level map for aggregated resource usage
-	// With instance type being the top level key, the mapped value is a map:
-	//   resource type (CPU, memory etc) -> the aggregated used time (in seconds) of the resource type
-	//
-	TrackedResourceMap map[string]map[string]int64
-
-	sync.RWMutex
-}
-
-func (ur *TrackedResource) Clone() *TrackedResource {
-	if ur == nil {
-		return nil
-	}
-	ret := NewTrackedResource()
-	ur.RLock()
-	defer ur.RUnlock()
-	for k, v := range ur.TrackedResourceMap {
-		dest := make(map[string]int64)
-		for key, element := range v {
-			dest[key] = element
-		}
-		ret.TrackedResourceMap[k] = dest
-	}
-	return ret
-}
-
-// Aggregate the resource usage to UsedResourceMap[instType]
-// The time the given resource used is the delta between the resource createTime and currentTime
-func (ur *TrackedResource) AggregateTrackedResource(instType string,
-	resource *Resource, bindTime time.Time) {
-	ur.Lock()
-	defer ur.Unlock()
-
-	releaseTime := time.Now()
-	timeDiff := int64(releaseTime.Sub(bindTime).Seconds())
-	aggregatedResourceTime, ok := ur.TrackedResourceMap[instType]
-	if !ok {
-		aggregatedResourceTime = map[string]int64{}
-	}
-	for key, element := range resource.Resources {
-		curUsage, ok := aggregatedResourceTime[key]
-		if !ok {
-			curUsage = 0
-		}
-		curUsage += int64(element) * timeDiff // resource size times timeDiff
-		aggregatedResourceTime[key] = curUsage
-	}
-	ur.TrackedResourceMap[instType] = aggregatedResourceTime
-}
-
 // Never update value of Zero
 var Zero = NewResource()
 
@@ -157,10 +103,6 @@ func NewResourceFromConf(configMap map[string]string) (*Resource, error) {
 	return res, nil
 }
 
-func NewTrackedResource() *TrackedResource {
-	return &TrackedResource{TrackedResourceMap: make(map[string]map[string]int64)}
-}
-
 func (r *Resource) String() string {
 	if r == nil {
 		return "nil resource"

pkg/common/resources/tracked_resources.go

@@ -0,0 +1,109 @@
+/*
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you 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 resources
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+// TrackedResource is a utility struct to keep track of application resource usage.
+type TrackedResource struct {
+	// TrackedResourceMap is a two-level map for aggregated resource usage.
+	// The top-level key is the instance type, and the value is a map:
+	//   resource type (CPU, memory, etc.) -> aggregated used time (in seconds) of the resource type.
+	TrackedResourceMap map[string]map[string]int64
+
+	sync.RWMutex
+}
+
+// NewTrackedResource creates a new instance of TrackedResource.
+func NewTrackedResource() *TrackedResource {
+	return &TrackedResource{TrackedResourceMap: make(map[string]map[string]int64)}
+}
+
+// NewTrackedResourceFromMap creates NewTrackedResource from the given map.
+// Using for Testing purpose only.
+func NewTrackedResourceFromMap(m map[string]map[string]int64) *TrackedResource {
+	if m == nil {
+		return NewTrackedResource()
+	}
+	return &TrackedResource{TrackedResourceMap: m}
+}
+
+func (tr *TrackedResource) String() string {
+	tr.RLock()
+	defer tr.RUnlock()
+
+	var resourceUsage []string
+	for instanceType, resourceTypeMap := range tr.TrackedResourceMap {
+		for resourceType, usageTime := range resourceTypeMap {
+			resourceUsage = append(resourceUsage, fmt.Sprintf("%s:%s=%d", instanceType, resourceType, usageTime))
+		}
+	}
+
+	return fmt.Sprintf("TrackedResource{%s}", strings.Join(resourceUsage, ","))
+}
+
+// Clone creates a deep copy of TrackedResource.
+func (tr *TrackedResource) Clone() *TrackedResource {
+	if tr == nil {
+		return nil
+	}
+	ret := NewTrackedResource()
+	tr.RLock()
+	defer tr.RUnlock()
+	for k, v := range tr.TrackedResourceMap {
+		dest := make(map[string]int64)
+		for key, element := range v {
+			dest[key] = element
+		}
+		ret.TrackedResourceMap[k] = dest
+	}
+	return ret
+}
+
+// AggregateTrackedResource aggregates resource usage to TrackedResourceMap[instType].
+// The time the given resource used is the delta between the resource createTime and currentTime.
+func (tr *TrackedResource) AggregateTrackedResource(instType string,
+	resource *Resource, bindTime time.Time) {
+	if resource == nil {
+		return
+	}
+	tr.Lock()
+	defer tr.Unlock()
+
+	releaseTime := time.Now()
+	timeDiff := int64(releaseTime.Sub(bindTime).Seconds())
+	aggregatedResourceTime, ok := tr.TrackedResourceMap[instType]
+	if !ok {
+		aggregatedResourceTime = map[string]int64{}
+	}
+	for key, element := range resource.Resources {
+		curUsage, ok := aggregatedResourceTime[key]
+		if !ok {
+			curUsage = 0
+		}
+		curUsage += int64(element) * timeDiff // resource size times timeDiff
+		aggregatedResourceTime[key] = curUsage
+	}
+	tr.TrackedResourceMap[instType] = aggregatedResourceTime
+}