internal: Making poolcache typed and merged into fscache (#2693)

Merged pool cache package into fscache to avoid import cycle. Also changed all types in pool cache from interface to specific types. Signed-off-by: Sanket Sudake <sanketsudake@gmail.com>
2023-01-15 23:50:05 +05:30
parent deb3523b59
commit 0edf2640b1
3 changed files with 60 additions and 54 deletions
@@ -35,7 +35,6 @@ import (
 	"github.com/fission/fission/pkg/crd"
 	ferror "github.com/fission/fission/pkg/error"
 	"github.com/fission/fission/pkg/executor/metrics"
-	"github.com/fission/fission/pkg/poolcache"
 )

 type fscRequestType int
@@ -68,12 +67,12 @@ type (
 	// FunctionServiceCache represents the function service cache
 	FunctionServiceCache struct {
 		logger            *zap.Logger
-		byFunction        *cache.Cache     // function-key -> funcSvc  : map[string]*funcSvc
-		byAddress         *cache.Cache     // address      -> function : map[string]metav1.ObjectMeta
-		byFunctionUID     *cache.Cache     // function uid -> function : map[string]metav1.ObjectMeta
-		connFunctionCache *poolcache.Cache // function-key -> funcSvc : map[string]*funcSvc
-		PodToFsvc         sync.Map         // pod-name -> funcSvc: map[string]*FuncSvc
-		WebsocketFsvc     sync.Map         // funcSvc-name -> bool: map[string]bool
+		byFunction        *cache.Cache // function-key -> funcSvc  : map[string]*funcSvc
+		byAddress         *cache.Cache // address      -> function : map[string]metav1.ObjectMeta
+		byFunctionUID     *cache.Cache // function uid -> function : map[string]metav1.ObjectMeta
+		connFunctionCache *PoolCache   // function-key -> funcSvc : map[string]*funcSvc
+		PodToFsvc         sync.Map     // pod-name -> funcSvc: map[string]*FuncSvc
+		WebsocketFsvc     sync.Map     // funcSvc-name -> bool: map[string]bool
 		requestChannel    chan *fscRequest
 	}

@@ -113,7 +112,7 @@ func MakeFunctionServiceCache(logger *zap.Logger) *FunctionServiceCache {
 		byFunction:        cache.MakeCache(0, 0),
 		byAddress:         cache.MakeCache(0, 0),
 		byFunctionUID:     cache.MakeCache(0, 0),
-		connFunctionCache: poolcache.NewPoolCache(logger.Named("conn_function_cache")),
+		connFunctionCache: NewPoolCache(logger.Named("conn_function_cache")),
 		requestChannel:    make(chan *fscRequest),
 	}
 	go fsc.service()
@@ -159,8 +158,8 @@ func (fsc *FunctionServiceCache) service() {
 		case LISTOLDPOOL:
 			fscs := fsc.connFunctionCache.ListAvailableValue()
 			funcObjects := make([]*FuncSvc, 0)
-			for _, funcSvc := range fscs {
-				if fsvc, ok := funcSvc.(*FuncSvc); ok && time.Since(fsvc.Atime) > req.age {
+			for _, fsvc := range fscs {
+				if time.Since(fsvc.Atime) > req.age {
 					funcObjects = append(funcObjects, fsvc)
 				}
 			}
@@ -192,14 +191,13 @@ func (fsc *FunctionServiceCache) GetByFunction(m *metav1.ObjectMeta) (*FuncSvc,
 func (fsc *FunctionServiceCache) GetFuncSvc(ctx context.Context, m *metav1.ObjectMeta, requestsPerPod int) (*FuncSvc, int, error) {
 	key := crd.CacheKey(m)

-	fsvcI, active, err := fsc.connFunctionCache.GetValue(ctx, key, requestsPerPod)
+	fsvc, active, err := fsc.connFunctionCache.GetSvcValue(ctx, key, requestsPerPod)
 	if err != nil {
 		fsc.logger.Info("Not found in Cache")
 		return nil, active, err
 	}

 	// update atime
-	fsvc := fsvcI.(*FuncSvc)
 	fsvc.Atime = time.Now()

 	fsvcCopy := *fsvc
@@ -230,7 +228,7 @@ func (fsc *FunctionServiceCache) GetByFunctionUID(uid types.UID) (*FuncSvc, erro

 // AddFunc adds a function service to pool cache.
 func (fsc *FunctionServiceCache) AddFunc(ctx context.Context, fsvc FuncSvc) {
-	fsc.connFunctionCache.SetValue(ctx, crd.CacheKey(fsvc.Function), fsvc.Address, &fsvc, fsvc.CPULimit)
+	fsc.connFunctionCache.SetSvcValue(ctx, crd.CacheKey(fsvc.Function), fsvc.Address, &fsvc, fsvc.CPULimit)
 	now := time.Now()
 	fsvc.Ctime = now
 	fsvc.Atime = now
@@ -0,0 +1,252 @@
+/*
+Copyright 2016 The Fission Authors.
+
+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 fscache
+
+import (
+	"context"
+	"fmt"
+
+	"go.uber.org/zap"
+	"k8s.io/apimachinery/pkg/api/resource"
+
+	ferror "github.com/fission/fission/pkg/error"
+	otelUtils "github.com/fission/fission/pkg/utils/otel"
+)
+
+type requestType int
+
+const (
+	getValue requestType = iota
+	listAvailableValue
+	setValue
+	markAvailable
+	deleteValue
+	setCPUUtilization
+)
+
+type (
+	// value used as "value" in cache
+	value struct {
+		val             *FuncSvc
+		activeRequests  int               // number of requests served by function pod
+		currentCPUUsage resource.Quantity // current cpu usage of the specialized function pod
+		cpuLimit        resource.Quantity // if currentCPUUsage is more than cpuLimit cache miss occurs in getValue request
+	}
+	// PoolCache implements a simple cache implementation having values mapped by two keys [function][address].
+	// As of now PoolCache is only used by poolmanager executor
+	PoolCache struct {
+		cache          map[string]map[string]*value
+		requestChannel chan *request
+		logger         *zap.Logger
+	}
+
+	request struct {
+		requestType
+		ctx             context.Context
+		function        string
+		address         string
+		value           *FuncSvc
+		requestsPerPod  int
+		cpuUsage        resource.Quantity
+		responseChannel chan *response
+	}
+	response struct {
+		error
+		allValues   []*FuncSvc
+		value       *FuncSvc
+		totalActive int
+	}
+)
+
+// NewPoolCache create a Cache object
+
+func NewPoolCache(logger *zap.Logger) *PoolCache {
+	c := &PoolCache{
+		cache:          make(map[string]map[string]*value),
+		requestChannel: make(chan *request),
+		logger:         logger,
+	}
+	go c.service()
+	return c
+}
+
+func (c *PoolCache) service() {
+	for {
+		req := <-c.requestChannel
+		resp := &response{}
+		switch req.requestType {
+		case getValue:
+			values, ok := c.cache[req.function]
+			found := false
+			if !ok {
+				resp.error = ferror.MakeError(ferror.ErrorNotFound,
+					fmt.Sprintf("function Name '%v' not found", req.function))
+			} else {
+				for addr := range values {
+					if values[addr].activeRequests < req.requestsPerPod && values[addr].currentCPUUsage.Cmp(values[addr].cpuLimit) < 1 {
+						// mark active
+						values[addr].activeRequests++
+						if c.logger.Core().Enabled(zap.DebugLevel) {
+							otelUtils.LoggerWithTraceID(req.ctx, c.logger).Debug("Increase active requests with getValue", zap.String("function", req.function), zap.String("address", addr), zap.Int("activeRequests", values[addr].activeRequests))
+						}
+						resp.value = values[addr].val
+						found = true
+						break
+					}
+				}
+				if !found {
+					resp.error = ferror.MakeError(ferror.ErrorNotFound, fmt.Sprintf("function '%v' all functions are busy", req.function))
+				}
+				resp.totalActive = len(values)
+			}
+			req.responseChannel <- resp
+		case setValue:
+			if _, ok := c.cache[req.function]; !ok {
+				c.cache[req.function] = make(map[string]*value)
+			}
+			if _, ok := c.cache[req.function][req.address]; !ok {
+				c.cache[req.function][req.address] = &value{}
+			}
+			c.cache[req.function][req.address].val = req.value
+			c.cache[req.function][req.address].activeRequests++
+			if c.logger.Core().Enabled(zap.DebugLevel) {
+				otelUtils.LoggerWithTraceID(req.ctx, c.logger).Debug("Increase active requests with setValue", zap.String("function", req.function), zap.String("address", req.address), zap.Int("activeRequests", c.cache[req.function][req.address].activeRequests))
+			}
+			c.cache[req.function][req.address].cpuLimit = req.cpuUsage
+		case listAvailableValue:
+			vals := make([]*FuncSvc, 0)
+			for key1, values := range c.cache {
+				for key2, value := range values {
+					debugLevel := c.logger.Core().Enabled(zap.DebugLevel)
+					if debugLevel {
+						otelUtils.LoggerWithTraceID(req.ctx, c.logger).Debug("Reading active requests", zap.String("function", key1), zap.String("address", key2), zap.Int("activeRequests", value.activeRequests))
+					}
+					if value.activeRequests == 0 {
+						if debugLevel {
+							otelUtils.LoggerWithTraceID(req.ctx, c.logger).Debug("Function service with no active requests", zap.String("function", key1), zap.String("address", key2), zap.Int("activeRequests", value.activeRequests))
+						}
+						vals = append(vals, value.val)
+					}
+				}
+			}
+			resp.allValues = vals
+			req.responseChannel <- resp
+		case setCPUUtilization:
+			if _, ok := c.cache[req.function]; !ok {
+				c.cache[req.function] = make(map[string]*value)
+			}
+			if _, ok := c.cache[req.function][req.address]; ok {
+				c.cache[req.function][req.address].currentCPUUsage = req.cpuUsage
+			}
+		case markAvailable:
+			if _, ok := c.cache[req.function]; ok {
+				if _, ok = c.cache[req.function][req.address]; ok {
+					if c.cache[req.function][req.address].activeRequests > 0 {
+						c.cache[req.function][req.address].activeRequests--
+						if c.logger.Core().Enabled(zap.DebugLevel) {
+							otelUtils.LoggerWithTraceID(req.ctx, c.logger).Debug("Decrease active requests", zap.String("function", req.function), zap.String("address", req.address), zap.Int("activeRequests", c.cache[req.function][req.address].activeRequests))
+						}
+					} else {
+						otelUtils.LoggerWithTraceID(req.ctx, c.logger).Error("Invalid request to decrease active requests", zap.String("function", req.function), zap.String("address", req.address), zap.Int("activeRequests", c.cache[req.function][req.address].activeRequests))
+					}
+				}
+			}
+		case deleteValue:
+			delete(c.cache[req.function], req.address)
+			req.responseChannel <- resp
+		default:
+			resp.error = ferror.MakeError(ferror.ErrorInvalidArgument,
+				fmt.Sprintf("invalid request type: %v", req.requestType))
+			req.responseChannel <- resp
+		}
+	}
+}
+
+// GetValue returns a function service with status in Active else return error
+func (c *PoolCache) GetSvcValue(ctx context.Context, function string, requestsPerPod int) (*FuncSvc, int, error) {
+	respChannel := make(chan *response)
+	c.requestChannel <- &request{
+		ctx:             ctx,
+		requestType:     getValue,
+		function:        function,
+		requestsPerPod:  requestsPerPod,
+		responseChannel: respChannel,
+	}
+	resp := <-respChannel
+	return resp.value, resp.totalActive, resp.error
+}
+
+// ListAvailableValue returns a list of the available function services stored in the Cache
+func (c *PoolCache) ListAvailableValue() []*FuncSvc {
+	respChannel := make(chan *response)
+	c.requestChannel <- &request{
+		requestType:     listAvailableValue,
+		responseChannel: respChannel,
+	}
+	resp := <-respChannel
+	return resp.allValues
+}
+
+// SetValue marks the value at key [function][address] as active(begin used)
+func (c *PoolCache) SetSvcValue(ctx context.Context, function, address string, value *FuncSvc, cpuLimit resource.Quantity) {
+	respChannel := make(chan *response)
+	c.requestChannel <- &request{
+		ctx:             ctx,
+		requestType:     setValue,
+		function:        function,
+		address:         address,
+		value:           value,
+		cpuUsage:        cpuLimit,
+		responseChannel: respChannel,
+	}
+}
+
+// SetCPUUtilization updates/sets the CPU utilization limit for the pod
+func (c *PoolCache) SetCPUUtilization(function, address string, cpuUsage resource.Quantity) {
+	c.requestChannel <- &request{
+		requestType:     setCPUUtilization,
+		function:        function,
+		address:         address,
+		cpuUsage:        cpuUsage,
+		responseChannel: make(chan *response),
+	}
+}
+
+// MarkAvailable marks the value at key [function][address] as available
+func (c *PoolCache) MarkAvailable(function, address string) {
+	respChannel := make(chan *response)
+	c.requestChannel <- &request{
+		requestType:     markAvailable,
+		function:        function,
+		address:         address,
+		responseChannel: respChannel,
+	}
+}
+
+// DeleteValue deletes the value at key composed of [function][address]
+func (c *PoolCache) DeleteValue(ctx context.Context, function, address string) error {
+	respChannel := make(chan *response)
+	c.requestChannel <- &request{
+		ctx:             ctx,
+		requestType:     deleteValue,
+		function:        function,
+		address:         address,
+		responseChannel: respChannel,
+	}
+	resp := <-respChannel
+	return resp.error
+}
@@ -0,0 +1,72 @@
+package fscache
+
+import (
+	"context"
+	"log"
+	"testing"
+
+	"k8s.io/apimachinery/pkg/api/resource"
+
+	"github.com/fission/fission/pkg/utils/loggerfactory"
+)
+
+func checkErr(err error) {
+	if err != nil {
+		log.Panicf("err: %v", err)
+	}
+}
+
+func TestPoolCache(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	logger := loggerfactory.GetLogger()
+	c := NewPoolCache(logger)
+
+	c.SetSvcValue(ctx, "func", "ip", &FuncSvc{
+		Name: "value",
+	}, resource.MustParse("45m"))
+
+	c.SetSvcValue(ctx, "func2", "ip2", &FuncSvc{
+		Name: "value2",
+	}, resource.MustParse("50m"))
+
+	c.SetSvcValue(ctx, "func2", "ip22", &FuncSvc{
+		Name: "value22",
+	}, resource.MustParse("33m"))
+
+	checkErr(c.DeleteValue(ctx, "func2", "ip2"))
+
+	cc := c.ListAvailableValue()
+	if len(cc) != 0 {
+		log.Panicf("expected 0 available items")
+	}
+
+	c.MarkAvailable("func", "ip")
+
+	_, active, err := c.GetSvcValue(ctx, "func", 5)
+	if active != 1 {
+		log.Panicln("Expected 1 active, found", active)
+	}
+	checkErr(err)
+
+	checkErr(c.DeleteValue(ctx, "func", "ip"))
+
+	_, _, err = c.GetSvcValue(ctx, "func", 5)
+	if err == nil {
+		log.Panicf("found deleted element")
+	}
+
+	c.SetSvcValue(ctx, "cpulimit", "100", &FuncSvc{
+		Name: "value",
+	}, resource.MustParse("3m"))
+	c.SetCPUUtilization("cpulimit", "100", resource.MustParse("4m"))
+
+	_, _, err = c.GetSvcValue(ctx, "cpulimit", 5)
+
+	if err == nil {
+		log.Panicf("received pod address with higher CPU usage than limit")
+	}
+	c.SetCPUUtilization("cpulimit", "100", resource.MustParse("2m"))
+	_, _, err = c.GetSvcValue(ctx, "cpulimit", 5)
+	checkErr(err)
+}