nodejs: implement 130/311 benchmarks

.github/workflows/regression.yml

@@ -22,11 +22,11 @@ jobs:
             architecture: "arm64"
           - platform: aws
             language: nodejs
-            version: "16"
+            version: "24"
             architecture: "x64"
           - platform: aws
             language: nodejs
-            version: "16"
+            version: "24"
             architecture: "arm64"
           - platform: aws
             language: cpp

benchmarks/000.microbenchmarks/010.sleep/nodejs/function.js

@@ -4,5 +4,5 @@ const timer = ms => new Promise( res => setTimeout(res, ms));
 exports.handler = async function(event) {
   var sleep =  event.sleep;
   timer(sleep*1000);
-  return sleep;
+  return {result: sleep};
 };

benchmarks/100.webapps/110.dynamic-html/nodejs/function.js

@@ -23,7 +23,7 @@ exports.handler = async function(event) {
     fs.readFile(file, "utf-8",
       function(err, data) {
         if(err) reject(err);
-        resolve(Mustache.render(data, input));
+        resolve({result: Mustache.render(data, input)});
       }
     );
   });

benchmarks/100.webapps/130.crud-api/nodejs/function.js

@@ -0,0 +1,78 @@
+const nosql = require('./nosql');
+
+const nosqlClient = nosql.nosql.get_instance();
+const nosqlTableName = "shopping_cart";
+
+async function addProduct(cartId, productId, productName, price, quantity) {
+  await nosqlClient.insert(
+    nosqlTableName,
+    ["cart_id", cartId],
+    ["product_id", productId],
+    { price: price, quantity: quantity, name: productName }
+  );
+}
+
+async function getProducts(cartId, productId) {
+  return await nosqlClient.get(
+    nosqlTableName, 
+    ["cart_id", cartId], 
+    ["product_id", productId]
+  );
+}
+
+async function queryProducts(cartId) {
+  const res = await nosqlClient.query(
+    nosqlTableName,
+    ["cart_id", cartId],
+    "product_id"
+  );
+
+  const products = [];
+  let priceSum = 0;
+  let quantitySum = 0;
+
+  for (const product of res) {
+    products.push(product.name);
+    priceSum += product.price * product.quantity;
+    quantitySum += product.quantity;
+  }
+
+  const avgPrice = quantitySum > 0 ? priceSum / quantitySum : 0.0;
+
+  return {
+    products: products,
+    total_cost: priceSum,
+    avg_price: avgPrice
+  };
+}
+
+exports.handler = async function(event) {
+  const results = [];
+
+  for (const request of event.requests) {
+    const route = request.route;
+    const body = request.body;
+    let res;
+
+    if (route === "PUT /cart") {
+      await addProduct(
+        body.cart,
+        body.product_id,
+        body.name,
+        body.price,
+        body.quantity
+      );
+      res = {};
+    } else if (route === "GET /cart/{id}") {
+      res = await getProducts(body.cart, request.path.id);
+    } else if (route === "GET /cart") {
+      res = await queryProducts(body.cart);
+    } else {
+      throw new Error(`Unknown request route: ${route}`);
+    }
+
+    results.push(res);
+  }
+
+  return results;
+};

benchmarks/100.webapps/130.crud-api/nodejs/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "crud-api",
+  "version": "1.0.0",
+  "description": "CRUD API benchmark",
+  "author": "",
+  "license": "",
+  "dependencies": {
+  }
+}

benchmarks/200.multimedia/210.thumbnailer/nodejs/function.js

@@ -25,5 +25,5 @@ exports.handler = async function(event) {
     }
   );
   await promise;
-  return {bucket: output_prefix, key: uploadName}
+  return {result: {bucket: output_prefix, key: uploadName}}
 };

benchmarks/200.multimedia/210.thumbnailer/nodejs/package.json.22

@@ -0,0 +1,10 @@
+{
+  "name": "",
+  "version": "1.0.0",
+  "description": "",
+  "author": "",
+  "license": "",
+  "dependencies": {
+    "sharp": "^0.33"
+  }
+}

benchmarks/200.multimedia/210.thumbnailer/nodejs/package.json.24

@@ -0,0 +1,10 @@
+{
+  "name": "",
+  "version": "1.0.0",
+  "description": "",
+  "author": "",
+  "license": "",
+  "dependencies": {
+    "sharp": "^0.33"
+  }
+}

benchmarks/300.utilities/311.compression/nodejs/function.js

@@ -0,0 +1,124 @@
+const fs = require('fs');
+const path = require('path');
+const archiver = require('archiver');
+const { v4: uuidv4 } = require('uuid');
+const storage = require('./storage');
+
+let storage_handler = new storage.storage();
+
+/**
+ * Calculate total size of a directory recursively
+ * @param {string} directory - Path to directory
+ * @returns {number} Total size in bytes
+ */
+function parseDirectory(directory) {
+  let size = 0;
+
+  function walkDir(dir) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const filepath = path.join(dir, file);
+      const stat = fs.statSync(filepath);
+      if (stat.isDirectory()) {
+        walkDir(filepath);
+      } else {
+        size += stat.size;
+      }
+    }
+  }
+
+  walkDir(directory);
+  return size;
+}
+
+/**
+ * Create a zip archive from a directory using archiver
+ * @param {string} sourceDir - Directory to compress
+ * @param {string} outputPath - Path for the output archive file
+ * @returns {Promise<void>}
+ */
+async function createZipArchive(sourceDir, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver('zip', {
+      zlib: { level: 9 } // Maximum compression
+    });
+
+    output.on('close', () => {
+      resolve();
+    });
+
+    archive.on('error', (err) => {
+      reject(err);
+    });
+
+    archive.pipe(output);
+
+    // Add all files from the directory, excluding the archive itself
+    archive.glob('**/*', {
+      cwd: sourceDir,
+      ignore: [path.basename(outputPath)]
+    });
+
+    archive.finalize();
+  });
+}
+
+exports.handler = async function(event) {
+  const bucket = event.bucket.bucket;
+  const input_prefix = event.bucket.input;
+  const output_prefix = event.bucket.output;
+  const key = event.object.key;
+
+  // Create unique download path
+  const download_path = path.join('/tmp', `${key}-${uuidv4()}`);
+  fs.mkdirSync(download_path, { recursive: true });
+
+  // Download directory from storage
+  const s3_download_begin = Date.now();
+  await storage_handler.downloadDirectory(bucket, path.join(input_prefix, key), download_path);
+  const s3_download_stop = Date.now();
+
+  // Calculate size of downloaded files
+  const size = parseDirectory(download_path);
+
+  // Compress directory
+  const compress_begin = Date.now();
+  const archive_name = `${key}.zip`;
+  const archive_path = path.join(download_path, archive_name);
+  await createZipArchive(download_path, archive_path);
+  const compress_end = Date.now();
+
+  // Get archive size
+  const archive_size = fs.statSync(archive_path).size;
+
+  // Upload compressed archive
+  const s3_upload_begin = Date.now();
+  const [key_name, uploadPromise] = storage_handler.upload(
+    bucket, 
+    path.join(output_prefix, archive_name), 
+    archive_path
+  );
+  await uploadPromise;
+  const s3_upload_stop = Date.now();
+
+  // Calculate times in microseconds
+  const download_time = (s3_download_stop - s3_download_begin) * 1000;
+  const upload_time = (s3_upload_stop - s3_upload_begin) * 1000;
+  const process_time = (compress_end - compress_begin) * 1000;
+
+  return {
+    result: {
+      bucket: bucket,
+      key: key_name
+    },
+    measurement: {
+      download_time: download_time,
+      download_size: size,
+      upload_time: upload_time,
+      upload_size: archive_size,
+      compute_time: process_time
+    }
+  };
+};
+

benchmarks/300.utilities/311.compression/nodejs/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "compression-benchmark",
+  "version": "1.0.0",
+  "description": "Compression benchmark for serverless platforms",
+  "dependencies": {
+    "uuid": "^10.0.0",
+    "archiver": "^7.0.0"
+  }
+}

benchmarks/wrappers/aws/nodejs/handler.js

@@ -35,7 +35,7 @@ exports.handler = async function(event, context) {
           end: end,
           compute_time: micro,
           results_time: 0,
-          result: {result: result},
+          result: result,
           is_cold: is_cold,
           request_id: context.awsRequestId
         }, http_trigger)

benchmarks/wrappers/aws/nodejs/nosql.js

@@ -0,0 +1,104 @@
+// Copyright 2020-2025 ETH Zurich and the SeBS authors. All rights reserved.
+//
+// This is pretty much a Node.js rewrite of our Python wrapper.
+
+
+
+const { DynamoDBDocument } = require("@aws-sdk/lib-dynamodb");
+const { DynamoDB } = require("@aws-sdk/client-dynamodb");
+
+class nosql {
+  constructor() {
+    this.client = DynamoDBDocument.from(new DynamoDB());
+    this._tables = {};
+  }
+
+  _get_table(table_name) {
+    if (!(table_name in this._tables)) {
+      const env_name = `NOSQL_STORAGE_TABLE_${table_name}`;
+      if (env_name in process.env) {
+        this._tables[table_name] = process.env[env_name];
+      } else {
+        throw new Error(
+          `Couldn't find an environment variable ${env_name} for table ${table_name}`
+        );
+      }
+    }
+    return this._tables[table_name];
+  }
+
+  async insert(table_name, primary_key, secondary_key, data) {
+    data[primary_key[0]] = primary_key[1];
+    data[secondary_key[0]] = secondary_key[1];
+    await this.client
+      .put({ TableName: this._get_table(table_name), Item: data });
+  }
+
+  async get(table_name, primary_key, secondary_key) {
+    const key = {};
+    key[primary_key[0]] = primary_key[1];
+    key[secondary_key[0]] = secondary_key[1];
+    const res = await this.client
+      .get({ TableName: this._get_table(table_name), Key: key });
+    return res.Item;
+  }
+
+  async update(table_name, primary_key, secondary_key, updates) {
+
+    const key = {};
+    key[primary_key[0]] = primary_key[1];
+    key[secondary_key[0]] = secondary_key[1];
+
+    const update_names = {};
+    const update_values = {};
+    const update_expression = ["SET"];
+    for (const [key_name, value] of Object.entries(updates)) {
+      update_expression.push(`#${key_name}_name = :${key_name}_value,`);
+      update_names[`#${key_name}_name`] = key_name;
+      update_values[`:${key_name}_value`] = value;
+    }
+    // remove trailing comma from the last assignment
+    update_expression[update_expression.length - 1] = update_expression[
+      update_expression.length - 1
+    ].slice(0, -1);
+
+    await this.client
+      .update({
+        TableName: this._get_table(table_name),
+        Key: key,
+        UpdateExpression: update_expression.join(" "),
+        ExpressionAttributeNames: update_names,
+        ExpressionAttributeValues: update_values,
+      });
+  }
+
+  async query(table_name, primary_key, _) {
+    const key_name = primary_key[0];
+    const res = await this.client
+      .query({
+        TableName: this._get_table(table_name),
+        KeyConditionExpression: "#key_name = :keyvalue",
+        ExpressionAttributeNames: { "#key_name": key_name },
+        ExpressionAttributeValues: { ":keyvalue": primary_key[1] },
+      });
+    return res.Items;
+  }
+
+  async delete(table_name, primary_key, secondary_key) {
+    const key = {};
+    key[primary_key[0]] = primary_key[1];
+    key[secondary_key[0]] = secondary_key[1];
+    await this.client
+      .delete({ TableName: this._get_table(table_name), Key: key });
+  }
+
+  static get_instance() {
+    // The instance is independent of the storage table,
+    // as we provide table name for each operation.
+    if (!nosql.instance) {
+      nosql.instance = new nosql();
+    }
+    return nosql.instance;
+  }
+}
+exports.nosql = nosql;