Java benchmarks support

.gitignore

@@ -182,3 +182,6 @@ cache
 # IntelliJ IDEA files
 .idea
 *.iml
+
+# Visual Studio Code files
+.vscode/

benchmarks/600.java/601.hello-world/config.json

@@ -0,0 +1,6 @@
+{
+    "timeout": 120,
+    "memory": 512,
+    "languages": ["java"]
+  }
+

benchmarks/600.java/601.hello-world/java/pom.xml

@@ -0,0 +1,38 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" 
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
+                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+
+    <!-- Group ID and Artifact ID uniquely identify the project -->
+    <groupId>faas</groupId>
+    <artifactId>601.hello-world</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging> <!-- The packaging type for the project (jar by default) -->
+
+    <!-- Configure the Java version (set to Java 8) -->
+    <properties>
+        <maven.compiler.source>1.8</maven.compiler.source>  <!-- Source compatibility (Java 8) -->
+        <maven.compiler.target>1.8</maven.compiler.target>  <!-- Target compatibility (Java 8) -->
+    </properties>
+
+    <!-- Define the main class to run the JAR -->
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.2.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <mainClass>faas.App</mainClass> <!-- Replace with your main class -->
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>
+

benchmarks/600.java/601.hello-world/java/src/main/java/faas/App.java

@@ -0,0 +1,7 @@
+package faas;
+
+public class App {
+    public static void main(String[] args) {
+        System.out.println("Hellooooooooooooooooooo, World!");
+    }
+}

benchmarks/wrappers/openwhisk/java/Main.java

@@ -0,0 +1,62 @@
+import faas.App;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import util.SessionBlob;
+import util.ShaSecurityProvider;
+import java.time.Instant;
+import java.time.Duration;
+import java.io.File;
+import java.io.IOException;
+//import jakarta.ws.rs.core.Response;
+
+
+public class Main {
+    public static JsonObject main(JsonObject args) {
+
+        // Logger logger = Logger.getLogger(FunctionHandler.class.getName());
+        // logger.setLevel(Level.INFO);
+
+        Gson gson = new Gson();
+        App function = new App();
+
+        long start_nano = System.nanoTime();
+
+        Instant begin = Instant.now();
+        JsonObject result = function.handler(args);
+        Instant end = Instant.now();
+
+        long end_nano = System.nanoTime();
+
+        // long computeTime = Duration.between(begin, end).toNanos() / 1000; // Convert nanoseconds to microseconds
+
+        long computeTime = end_nano - start_nano;
+        boolean isCold = false;
+        String fileName = "/cold_run"; 
+
+        File file = new File(fileName);
+        if (!file.exists()) {
+            isCold = true;
+            try {
+                file.createNewFile();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        // Convert to Unix timestamp in seconds.microseconds
+        String formattedBegin = String.format("%d.%06d", begin.getEpochSecond(), begin.getNano() / 1000); // Convert nanoseconds to microseconds
+        String formattedEnd = String.format("%d.%06d", end.getEpochSecond(), end.getNano() / 1000);
+
+        String requestId = System.getenv("__OW_ACTIVATION_ID");  
+
+        JsonObject jsonResult = new JsonObject();
+        jsonResult.addProperty("begin", formattedBegin); 
+        jsonResult.addProperty("end", formattedEnd);
+        jsonResult.addProperty("request_id", requestId);  
+        jsonResult.addProperty("compute_time", computeTime);
+        jsonResult.addProperty("is_cold", isCold);
+        jsonResult.addProperty("result", result.toString());
+        return jsonResult;
+    }
+
+}

config/example2.json

@@ -0,0 +1,69 @@
+{
+    "experiments": {
+      "deployment": "openwhisk",
+      "update_code": false,
+      "update_storage": false,
+      "download_results": false,
+      "runtime": {
+        "language": "java",
+        "version": "8"
+      },
+      "type": "invocation-overhead",
+      "perf-cost": {
+        "benchmark": "601.hello-world",
+        "experiments": ["cold", "warm", "burst", "sequential"],
+        "input-size": "test",
+        "repetitions": 50,
+        "concurrent-invocations": 50,
+        "memory-sizes": [128, 256]
+      },
+      "network-ping-pong": {
+        "invocations": 50,
+        "repetitions": 1000,
+        "threads": 1
+      },
+      "invocation-overhead": {
+        "repetitions": 5,
+        "N": 20,
+        "type": "payload",
+        "payload_begin": 1024,
+        "payload_end": 6251000,
+        "payload_points": 20,
+        "code_begin": 1048576,
+        "code_end": 261619712,
+        "code_points": 20
+      },
+      "eviction-model": {
+        "invocations": 1,
+        "function_copy_idx": 0,
+        "repetitions": 5,
+        "sleep": 1
+      }
+    },
+    "deployment": {
+      "openwhisk": {
+        "shutdownStorage": false,
+        "removeCluster": false,
+        "wskBypassSecurity": "true",
+        "wskExec": "wsk",
+        "experimentalManifest": false,
+        "docker_registry": {
+          "registry": "",
+          "username": "",
+          "password": ""
+        },
+        "storage": {
+          "address": "",
+          "mapped_port": 9011,
+          "access_key": "",
+          "secret_key": "",
+          "instance_id": "",
+          "output_buckets": [],
+          "input_buckets": [],
+          "type": "minio"
+         }
+
+      }
+    }
+  }
+

config/systems.json

@@ -243,6 +243,24 @@
             "minio": "7.0.16"
           }
         }
+      },
+      "java": {
+        "base_images": {
+          "8": "openwhisk/java8action"
+        },
+        "images": [
+          "function"
+        ],
+        "username": "docker_user",
+        "deployment": {
+          "files": [
+            "Main.java",
+            "Storage.java"
+          ],
+          "packages": {
+            "minio": "8.5.9"
+          }
+        }
       }
     }
   }

dockerfiles/openwhisk/java/Dockerfile.function

@@ -0,0 +1,8 @@
+ARG BASE_IMAGE
+FROM $BASE_IMAGE
+COPY . /function/
+
+# RUN apt-get update && apt-get install -y maven
+
+# # Check if pom.xml exists before running Maven
+# RUN if [ -f ./pom.xml ]; then mvn clean install; else echo "pom.xml not found, aborting build." && exit 1; fi

sebs.py

@@ -63,7 +63,7 @@ def simplified_common_params(func):
     @click.option(
         "--language",
         default=None,
-        type=click.Choice(["python", "nodejs"]),
+        type=click.Choice(["python", "nodejs", "java"]),
         help="Benchmark language",
     )
     @click.option("--language-version", default=None, type=str, help="Benchmark language version")

sebs/benchmark.py

@@ -1,6 +1,7 @@
 import glob
 import hashlib
 import json
+import subprocess
 import os
 import shutil
 import subprocess
@@ -200,8 +201,9 @@ def hash_directory(directory: str, deployment: str, language: str):
         FILES = {
             "python": ["*.py", "requirements.txt*"],
             "nodejs": ["*.js", "package.json"],
+            "java": ["*.java", "pom.xml"],
         }
-        WRAPPERS = {"python": "*.py", "nodejs": "*.js"}
+        WRAPPERS = {"python": "*.py", "nodejs": "*.js", "java": "*.java"}
         NON_LANG_FILES = ["*.sh", "*.json"]
         selected_files = FILES[language] + NON_LANG_FILES
         for file_type in selected_files:
@@ -250,16 +252,51 @@ def copy_code(self, output_dir):
         FILES = {
             "python": ["*.py", "requirements.txt*"],
             "nodejs": ["*.js", "package.json"],
+            "java": ["pom.xml"],
         }
         path = os.path.join(self.benchmark_path, self.language_name)
+
         for file_type in FILES[self.language_name]:
             for f in glob.glob(os.path.join(path, file_type)):
                 shutil.copy2(os.path.join(path, f), output_dir)
+
+        # copy src folder of java (java benchmarks are maven project and need directories)
+        if self.language_name == "java":
+           output_src_dir = os.path.join(output_dir, "src")
+
+           if os.path.exists(output_src_dir):
+           # If src dir in output exist, remove the directory and all its contents
+                shutil.rmtree(output_src_dir)
+           #To have contents of src directory in the direcory named src located in output 
+           shutil.copytree(os.path.join(path, "src"), output_src_dir)
+
         # support node.js benchmarks with language specific packages
         nodejs_package_json = os.path.join(path, f"package.json.{self.language_version}")
         if os.path.exists(nodejs_package_json):
             shutil.copy2(nodejs_package_json, os.path.join(output_dir, "package.json"))
 
+    #This is for making jar file and add it to docker directory
+    def add_java_output(self, code_dir):
+
+        if self.language_name == "java":
+
+            # Step 1: Move Main.java o src directory
+            src_dir = os.path.join(code_dir, "src", "main", "java")
+            if os.path.exists(code_dir):
+                main_java_path = os.path.join(code_dir, "Main.java")
+                if os.path.exists(main_java_path):
+                    shutil.move(main_java_path, src_dir)
+
+            # Step 2: Run mvn clean install
+            try:
+                # Navigate to the code directory where the pom.xml file is located
+                subprocess.run(['mvn', 'clean', 'install'], cwd=code_dir, check=True, text=True, capture_output=True)
+                print("Maven build successful!")
+            except subprocess.CalledProcessError as e:
+                print(f"Error during Maven build:\n{e.stdout}\n{e.stderr}")
+                return         
+
+
     def add_benchmark_data(self, output_dir):
         cmd = "/bin/bash {benchmark_path}/init.sh {output_dir} false"
         paths = [
@@ -288,6 +325,16 @@ def add_deployment_files(self, output_dir):
         for file in handlers:
             shutil.copy2(file, os.path.join(output_dir))
 
+    def add_deployment_package_java(self, output_dir):
+        # append to the end of requirements file
+        packages = self._system_config.deployment_packages(
+            self._deployment_name, self.language_name
+        )
+        if len(packages):
+            with open(os.path.join(output_dir, "requirements.txt"), "a") as out:
+                for package in packages:
+                    out.write(package)
+
     def add_deployment_package_python(self, output_dir):
         # append to the end of requirements file
         packages = self._system_config.deployment_packages(
@@ -319,6 +366,8 @@ def add_deployment_package(self, output_dir):
             self.add_deployment_package_python(output_dir)
         elif self.language == Language.NODEJS:
             self.add_deployment_package_nodejs(output_dir)
+        elif self.language == Language.JAVA:
+            self.add_deployment_package_java(output_dir)
         else:
             raise NotImplementedError
 
@@ -497,6 +546,7 @@ def build(
         self.copy_code(self._output_dir)
         self.add_benchmark_data(self._output_dir)
         self.add_deployment_files(self._output_dir)
+        self.add_java_output(self._output_dir)
         self.add_deployment_package(self._output_dir)
         self.install_dependencies(self._output_dir)
         self._code_location, self._code_size = deployment_build_step(

sebs/faas/function.py

@@ -263,6 +263,7 @@ def deserialize(cached_config: dict) -> "Trigger":
 class Language(Enum):
     PYTHON = "python"
     NODEJS = "nodejs"
+    JAVA = "java"
 
     # FIXME: 3.7+ python with future annotations
     @staticmethod
@@ -299,7 +300,7 @@ def serialize(self) -> dict:
 
     @staticmethod
     def deserialize(config: dict) -> Runtime:
-        languages = {"python": Language.PYTHON, "nodejs": Language.NODEJS}
+        languages = {"python": Language.PYTHON, "nodejs": Language.NODEJS, "java": Language.JAVA}
         return Runtime(language=languages[config["language"]], version=config["version"])