benchmark 3 inserts con spring tmb

Author: Frtrillo

pom.xml

@@ -43,6 +43,9 @@
       <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
+        <configuration>
+          <mainClass>com.example.iotbench.IotBenchApplication</mainClass>
+        </configuration>
       </plugin>
     </plugins>
   </build>

result_spring_ultra_fast.txt

@@ -0,0 +1,9 @@
+Running 1m test @ http://localhost:8080/ultra/ingest
+  12 threads and 2000 connections
+  Thread Stats   Avg      Stdev     Max   +/- Stdev
+    Latency   188.18ms  322.65ms   2.00s    87.31%
+    Req/Sec     2.08k     1.16k    9.66k    69.49%
+  1300935 requests in 1.00m, 210.10MB read
+  Socket errors: connect 0, read 0, write 0, timeout 7274
+Requests/sec:  21662.76
+Transfer/sec:      3.50MB

run_spring_ultra_fast.sh

@@ -0,0 +1,121 @@
+#!/bin/bash
+set -e
+
+echo "=== Spring Boot Ultra-Fast Benchmark ==="
+echo "Spring Boot optimizado al máximo para comparación justa:"
+echo "- CON base de datos H2 (equivalente a SQLite)"
+echo "- Sin background processing"
+echo "- Sin AsyncWorker"
+echo "- Sin logging innecesario"
+echo "- Prepared statements optimizados (JdbcTemplate)"
+echo "- Virtual Threads habilitados"
+echo ""
+
+JAR=target/iot-bench-0.1.0.jar
+
+# Function to wait for port to be free
+wait_for_port_free() {
+    local port=$1
+    local timeout=30
+    local count=0
+    
+    echo "Waiting for port $port to be free..."
+    while lsof -Pi :$port -sTCP:LISTEN -t >/dev/null 2>&1; do
+        if [ $count -ge $timeout ]; then
+            echo "Timeout waiting for port $port to be free"
+            return 1
+        fi
+        sleep 1
+        count=$((count + 1))
+    done
+    echo "Port $port is now free"
+}
+
+# Function to wait for port to be ready
+wait_for_port_ready() {
+    local port=$1
+    local timeout=30
+    local count=0
+    
+    echo "Waiting for port $port to be ready..."
+    while ! curl -s http://localhost:$port/ultra/health >/dev/null 2>&1; do
+        if [ $count -ge $timeout ]; then
+            echo "Timeout waiting for port $port to be ready, trying anyway..."
+            return 0
+        fi
+        sleep 1
+        count=$((count + 1))
+    done
+    echo "Port $port is ready"
+}
+
+# Function to stop application gracefully
+stop_app() {
+    local pid=$1
+    local name=$2
+    if [ ! -z "$pid" ] && kill -0 $pid 2>/dev/null; then
+        echo "Stopping $name (PID: $pid)..."
+        kill $pid
+        
+        # Wait for process to stop
+        local count=0
+        while kill -0 $pid 2>/dev/null && [ $count -lt 15 ]; do
+            sleep 1
+            count=$((count + 1))
+        done
+        
+        # Force kill if still running
+        if kill -0 $pid 2>/dev/null; then
+            echo "Force killing $name..."
+            kill -9 $pid 2>/dev/null || true
+        fi
+        
+        wait_for_port_free 8080
+    fi
+}
+
+# Generate payload
+echo "Generating payload..."
+python3 generate_payload.py > payload.json
+
+# Clean up any existing processes
+echo "Cleaning up any existing processes..."
+pkill -f "iot-bench-0.1.0.jar" || true
+wait_for_port_free 8080
+
+echo ""
+echo "=== Spring Boot Ultra-Fast (Virtual Threads ON) ==="
+java -Xms2g -Xmx2g -jar $JAR --spring.threads.virtual.enabled=true --spring.profiles.active=ultrafast &
+SPRING_ULTRA_PID=$!
+wait_for_port_ready 8080
+echo "Running ultra-fast benchmark..."
+wrk -t12 -c2000 -d60s -s post.lua http://localhost:8080/ultra/ingest > result_spring_ultra_fast.txt
+stop_app $SPRING_ULTRA_PID "Spring Boot Ultra-Fast"
+
+echo ""
+echo "=== SPRING BOOT ULTRA-FAST RESULTS ==="
+echo "Spring Boot Ultra-Fast (Virtual Threads):"
+grep -E "(Requests/sec|Transfer/sec|Latency)" result_spring_ultra_fast.txt || echo "No results found"
+
+echo ""
+echo "=== COMPARISON WITH NESTJS ULTRA-FAST ==="
+if [ -f "result_ultra_fast_bun.txt" ]; then
+    echo "NestJS Ultra-Fast (Bun + SQLite nativo):"
+    grep -E "(Requests/sec|Transfer/sec)" result_ultra_fast_bun.txt || echo "No results"
+    echo ""
+fi
+
+if [ -f "result_ultra_fast_node.txt" ]; then
+    echo "NestJS Ultra-Fast (Node.js + SQLite3):"
+    grep -E "(Requests/sec|Transfer/sec)" result_ultra_fast_node.txt || echo "No results"
+    echo ""
+fi
+
+echo "Spring Boot Ultra-Fast (Java + H2):"
+grep -E "(Requests/sec|Transfer/sec)" result_spring_ultra_fast.txt || echo "No results"
+
+echo ""
+echo "🎯 FAIR COMPARISON: Framework vs Framework (Ultra-Optimized)"
+echo "   - NestJS + Fastify + SQLite vs Spring Boot + H2"
+echo "   - Sin background processing en ninguno"
+echo "   - Máximo rendimiento en ambos"

src/main/java/com/example/iotbench/IotBenchApplication.java

@@ -3,9 +3,11 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.context.annotation.ComponentScan;
 
 @SpringBootApplication
 @EnableAsync
+@ComponentScan(basePackageClasses = {IotBenchApplication.class, UltraFastController.class})
 public class IotBenchApplication {
     public static void main(String[] args) {
         SpringApplication.run(IotBenchApplication.class, args);

src/main/java/com/example/iotbench/UltraFastApplication.java

@@ -0,0 +1,17 @@
+package com.example.iotbench;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+
+@SpringBootApplication
+@ComponentScan(basePackageClasses = {UltraFastController.class})
+public class UltraFastApplication {
+    public static void main(String[] args) {
+        // Disable banner and reduce startup overhead
+        SpringApplication app = new SpringApplication(UltraFastApplication.class);
+        app.setBannerMode(org.springframework.boot.Banner.Mode.OFF);
+        app.setLogStartupInfo(false);
+        app.run(args);
+    }
+}

src/main/java/com/example/iotbench/UltraFastController.java

@@ -0,0 +1,79 @@
+package com.example.iotbench;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.jdbc.core.JdbcTemplate;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicLong;
+
+@RestController
+@RequestMapping("/ultra")
+public class UltraFastController {
+
+    private final JdbcTemplate jdbc;
+    private final AtomicLong counter = new AtomicLong(0);
+    
+    // Pre-allocated objects to avoid GC pressure (like the NestJS version)
+    private final Map<String, Object> responseTemplate = new HashMap<>();
+    private final Map<String, Object> healthTemplate = new HashMap<>();
+
+    public UltraFastController(JdbcTemplate jdbc) {
+        this.jdbc = jdbc;
+        initTable();
+        
+        // Pre-populate response templates
+        responseTemplate.put("id", "");
+        responseTemplate.put("t_ms", 0.0);
+        
+        healthTemplate.put("status", "ok");
+        healthTemplate.put("timestamp", "");
+        healthTemplate.put("runtime", "Spring Boot");
+        healthTemplate.put("count", 0L);
+    }
+
+    private void initTable() {
+        jdbc.execute("CREATE TABLE IF NOT EXISTS iot_payload_ultra (id VARCHAR(36) PRIMARY KEY, content CLOB, ts BIGINT)");
+    }
+
+    @PostMapping("ingest")
+    public ResponseEntity<Map<String,Object>> ingest(@RequestBody Map<String,Object> payload) {
+        long start = System.nanoTime();
+        
+        try {
+            // Ultra-fast ID generation (like NestJS version)
+            long count = counter.incrementAndGet();
+            String id = "id_" + count + "_" + System.currentTimeMillis();
+            
+            // Convert payload to JSON (minimal processing)
+            String content = payload.toString(); // Faster than ObjectMapper
+            long timestamp = System.currentTimeMillis();
+            
+            // Ultra-fast database insert (prepared statement equivalent)
+            jdbc.update("INSERT INTO iot_payload_ultra (id, content, ts) VALUES (?, ?, ?)", 
+                       id, content, timestamp);
+            
+            // No background processing - just return immediately (like NestJS ultra-fast)
+            long elapsedNanos = System.nanoTime() - start;
+            double elapsedMs = elapsedNanos / 1_000_000.0;
+            
+            // Reuse object to avoid allocation (like NestJS version)
+            responseTemplate.put("id", id);
+            responseTemplate.put("t_ms", Math.round(elapsedMs * 100.0) / 100.0);
+            
+            return ResponseEntity.ok(responseTemplate);
+            
+        } catch (Exception e) {
+            Map<String, Object> error = Map.of("error", "Internal server error");
+            return ResponseEntity.status(500).body(error);
+        }
+    }
+
+    @GetMapping("health")
+    public ResponseEntity<Map<String,Object>> health() {
+        // Reuse object to avoid allocation (like NestJS version)
+        healthTemplate.put("timestamp", new Date().toString());
+        healthTemplate.put("count", counter.get());
+        
+        return ResponseEntity.ok(healthTemplate);
+    }
+}

target/classes/com/example/iotbench/IotBenchApplication.class

@@ -1,4 +1,6 @@
 com/example/iotbench/AsyncWorker.class
+com/example/iotbench/UltraFastApplication.class
+com/example/iotbench/UltraFastController.class
 com/example/iotbench/IngestService.class
 com/example/iotbench/IotBenchApplication.class
 com/example/iotbench/IngestController.class