Distribution of Multi-Architecture Requests in Serverledge

.github/workflows/run_tests.yml

@@ -0,0 +1,26 @@
+name: Run Tests CI
+
+on:
+  push:
+
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: "1.24.0"
+
+      - name: Checkout branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.ref_name }}
+
+      - name: Install dependencies
+        run: make
+
+      - name: Run tests
+        run: make unit-test && make test

Makefile

@@ -14,7 +14,7 @@ serverledge-cli:
 executor:
 	CGO_ENABLED=0 $(GO) build -o $(BIN)/$@ cmd/$@/executor.go
 
-DOCKERHUB_USER=grussorusso
+DOCKERHUB_USER=fmuschera
 images:  image-python310 image-nodejs17ng image-base
 image-python310:
 	docker build -t $(DOCKERHUB_USER)/serverledge-python310 -f images/python310/Dockerfile .
@@ -28,8 +28,16 @@ push-images:
 	docker push $(DOCKERHUB_USER)/serverledge-base
 	docker push $(DOCKERHUB_USER)/serverledge-nodejs17ng
 
+# Runs integration tests (all tests EXCEPT unit tests)
 test:
-	go test -v ./...
+	$(GO) test -v $(shell $(GO) list ./... | grep -Ev 'internal/container|examples')
 
-.PHONY: serverledge serverledge-cli lb executor test images
+# Runs only unit tests
+unit-test:
+	go test -v -short ./internal/container/... ./internal/lb/...
+
+.PHONY: serverledge serverledge-cli lb executor test unit-test integration-test images
+
+clean:
+	@test -n "$(BIN)" && [ -d "$(BIN)" ] && rm -rf $(BIN) || { echo "Invalid BIN directory: $(BIN)"; exit 1; } && go clean -testcache
 

README.md

@@ -69,12 +69,12 @@ Start a local Serverledge node:
 
 Register a function `func` from example python code (the handler is formatted like this: $(filename).$(functionName)):
 
-	$ bin/serverledge-cli create -f func --memory 600 --src examples/hello.py --runtime python310 --handler "hello.handler"
+	$ bin/serverledge-cli create -f func --memory 600 --src examples/hello.py --runtime python314 --handler "hello.handler"
 
 Register a function `func` from example javascript code (the handler is formatted like this: $(filename) and the name of the function is "handler"):
 
-	$ bin/serverledge-cli create -f func --memory 600 --src examples/hello.js --runtime nodejs17 --handler "hello"
-    $ bin/serverledge-cli create -f func --memory 600 --src examples/inc.js --runtime nodejs17 --handler "inc"
+	$ bin/serverledge-cli create -f func --memory 600 --src examples/hello.js --runtime nodejs17ng --handler "hello"
+    $ bin/serverledge-cli create -f func --memory 600 --src examples/inc.js --runtime nodejs17ng --handler "inc"
 
 Invoke `func` with arguments `a=2` and `b=3`:
 

cmd/lb/main.go

@@ -2,12 +2,14 @@ package main
 
 import (
 	"fmt"
-	"github.com/serverledge-faas/serverledge/internal/node"
 	"log"
 	"os"
 	"os/signal"
 	"time"
 
+	"github.com/serverledge-faas/serverledge/internal/mab"
+	"github.com/serverledge-faas/serverledge/internal/node"
+
 	"golang.org/x/net/context"
 
 	"github.com/labstack/echo/v4"
@@ -59,5 +61,6 @@ func main() {
 	// Register a signal handler to cleanup things on termination
 	registerTerminationHandler(e)
 
+	mab.InitBanditManager()
 	lb.StartReverseProxy(e, myArea)
 }

examples/HelloFunction.java

@@ -0,0 +1,29 @@
+package com.test;
+
+// The compiled jar used by serverledge-cli is in ./java_build/target
+
+
+import java.util.Map;
+import java.util.HashMap;
+
+
+public class HelloFunction {
+
+
+    public Map<String, Object> handler(Object params, Map<String, Object> context) {
+        // Test output capture (stdout)
+        System.out.println("Log: Iniziata esecuzione Java Function!");
+        System.out.println("Log: Parametri ricevuti: " + params);
+
+        // Test output capture (stderr)
+        System.err.println("[DEBUG]: This is a debug message on stderr");
+
+
+        Map<String, Object> result = new HashMap<>();
+        result.put("message", "Hello from the Java default runtime of Serverledge!");
+        result.put("received_params", params);
+        result.put("java_version", System.getProperty("java.version"));
+
+        return result;
+    }
+}

examples/experiments/amd-faster.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"runtime"
+
+	"github.com/serverledge-faas/serverledge/serverledge"
+)
+
+// Handler is the entry point for Serverledge.
+// It performs AES-GCM encryption on a generated dataset.
+func myHandler(params map[string]interface{}) (interface{}, error) {
+	// Default data size: 128MB
+	dataSize := 256 * 1024 * 1024
+	if val, ok := params["size"].(float64); ok {
+		dataSize = int(val)
+	}
+
+	// Default passes: 5
+	passes := 5
+
+	// Prepare random-like data (deterministic fill to avoid generation overhead)
+	data := make([]byte, dataSize)
+	for i := 0; i < len(data); i++ {
+		data[i] = byte(i)
+	}
+
+	key := make([]byte, 32) // 256-bit key
+	nonce := make([]byte, 12)
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(0)
+	}
+
+	aesgcm, err := cipher.NewGCM(block)
+	if err != nil {
+		panic(0)
+	}
+
+	// Destination buffer with capacity for overhead
+	dst := make([]byte, 0, len(data)+aesgcm.Overhead())
+
+	// Execution: Encrypt data multiple times on a single thread
+	// This stresses the CPU pipeline and vector instructions (VAES/NEON)
+	for i := 0; i < passes; i++ {
+		dst = aesgcm.Seal(dst[:0], nonce, data, nil)
+	}
+
+	return map[string]interface{}{
+		"message":      "AES encryption completed",
+		"processed_gb": (float64(dataSize) * float64(passes)) / 1024 / 1024 / 1024,
+		"passes":       passes,
+		"arch":         runtime.GOARCH,
+	}, nil
+}
+
+func main() {
+	// Start the Serverledge runtime. This is a blocking function since it will start an HTTP server inside the
+	// container, waiting for the signal to execute the function.
+	serverledge.Start(myHandler)
+}

examples/experiments/arm-faster.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"compress/gzip"
+	"io"
+	"runtime"
+	"sync"
+
+	"github.com/serverledge-faas/serverledge/serverledge"
+	_ "go.uber.org/automaxprocs"
+)
+
+// Handler is the entry point for Serverledge.
+// It performs parallel Gzip compression utilizing all available logical CPUs.
+func myHandler(params map[string]interface{}) (interface{}, error) {
+	// Default base size: 128MB
+	baseSize := 256 * 1024 * 1024
+	if val, ok := params["size"].(float64); ok {
+		baseSize = int(val)
+	}
+
+	// Multiplier to increase total workload: default 4
+	multiplier := 10
+
+	// Prepare data
+	data := make([]byte, baseSize)
+	for i := 0; i < len(data); i++ {
+		data[i] = byte(i)
+	}
+
+	// Detect available CPUs to spawn correct number of goroutines
+	numThreads := runtime.NumCPU()
+
+	// Calculate total workload and chunk size per thread
+	totalDataSize := baseSize * multiplier
+	chunkSize := totalDataSize / numThreads
+	if chunkSize > len(data) {
+		chunkSize = len(data)
+	}
+
+	var wg sync.WaitGroup
+
+	// Execution: Parallel compression
+	for t := 0; t < numThreads; t++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			// We define the source slice based on chunk size.
+			// Note: We are compressing the same memory region repeatedly if total > base,
+			// but this is fine for testing CPU throughput.
+			src := data[:chunkSize]
+
+			w := gzip.NewWriter(io.Discard)
+			_, _ = w.Write(src)
+			w.Close()
+		}()
+	}
+
+	wg.Wait()
+
+	return map[string]interface{}{
+		"message":    "Gzip compression completed",
+		"total_size": totalDataSize,
+		"arch":       runtime.GOARCH,
+		"cpu":        runtime.NumCPU(),
+	}, nil
+}
+
+func main() {
+	// Start the Serverledge runtime. This is a blocking function since it will start an HTTP server inside the
+	// container, waiting for the signal to execute the function.
+	serverledge.Start(myHandler)
+}

examples/experiments/arm-target.yaml

@@ -0,0 +1,11 @@
+registry:
+  area: "cloud-region"
+  udp.port: 9877
+
+
+etcd:
+  address: "5.6.7.8:2379" # set to IP of VM hosting the LB (public one)
+
+container:
+  pool:
+    memory: 4096

examples/experiments/cpu_hogger.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+OUTPUT_FILE="$SCRIPT_DIR/cpu_hogger.csv"
+
+start_ts=$(date +%s.%N)
+
+./bin/serverledge-cli invoke -f cpu_hogger -p 'duration:180' -p 'memory:800'
+
+end_ts=$(date +%s.%N)
+
+if [[ ! -s "$OUTPUT_FILE" ]]; then
+    printf "start_ts,end_ts\n" >> "$OUTPUT_FILE"
+fi
+
+printf "%s,%s\n" "$start_ts" "$end_ts" >> "$OUTPUT_FILE"
+
+
+
+echo "Done"

examples/experiments/lb-config-MAB.yaml

@@ -0,0 +1,14 @@
+
+registry:
+  area: "cloud-region"
+  udp.port: 9877
+
+lb:
+  replicas: 128
+  mode: "MAB"
+  refresh_interval: 30
+
+mab.policy: "LinUCB"
+
+etcd:
+  address: "127.0.0.1:2379"

examples/experiments/lb-config-RR.yaml

@@ -0,0 +1,13 @@
+
+registry:
+  area: "cloud-region"
+  udp.port: 9877
+
+lb:
+  replicas: 128
+  mode: "RoundRobin"
+  refresh_interval: 30
+
+
+etcd:
+  address: "127.0.0.1:2379"

examples/experiments/linpack.py

@@ -0,0 +1,61 @@
+import time
+import random
+
+
+MATRIX_SIZE = 400
+
+def gaussian_elimination(A, B):
+
+    n = len(A)
+    M = [A[i][:] + [B[i]] for i in range(n)]
+
+    for i in range(n):
+        pivot = M[i][i]
+        if pivot == 0: pivot = 1.0e-10
+
+        for j in range(i + 1, n):
+            factor = M[j][i] / pivot
+            for k in range(i, n + 1):
+                M[j][k] -= factor * M[i][k]
+
+    x = [0.0] * n
+    for i in range(n - 1, -1, -1):
+        sum_ax = sum(M[i][j] * x[j] for j in range(i + 1, n))
+        x[i] = (M[i][n] - sum_ax) / M[i][i]
+
+    return x
+
+def handler(params, context):
+    n = MATRIX_SIZE
+
+    ops = (2.0 * n * n * n) / 3.0 + (2.0 * n * n)
+
+    A = []
+    for _ in range(n):
+        row = [(random.random() - 0.5) for _ in range(n)]
+        A.append(row)
+
+    B = []
+    for row in A:
+        B.append(sum(row))
+
+    start = time.time()
+
+    x = gaussian_elimination(A, B)
+
+    duration = time.time() - start
+
+    if duration <= 0:
+        duration = 0.000001
+
+    mflops = (ops * 1e-6 / duration)
+
+    validity_check = abs(x[0] - 1.0) < 1e-4
+
+    return {
+        "function": "linpack_pure",
+        "matrix_size": n,
+        "mflops": mflops,
+        "latency_seconds": duration,
+        "valid": validity_check
+    }