Update app.py

app.py

@@ -114,18 +114,35 @@ if [ "$AVAILABLE_MEM" -lt 20 ]; then
     exit 1
 fi
 
-# Calculate heap size (30% of available, min 4MB, max 12MB)
-HEAP_SIZE=$((AVAILABLE_MEM * 30 / 100))
+# Calculate heap size (20% of available, min 4MB, max 8MB)
+HEAP_SIZE=$((AVAILABLE_MEM * 20 / 100))
 if [ "$HEAP_SIZE" -lt 4 ]; then
     HEAP_SIZE=4
-elif [ "$HEAP_SIZE" -gt 12 ]; then
-    HEAP_SIZE=12
+elif [ "$HEAP_SIZE" -gt 8 ]; then
+    HEAP_SIZE=8
 fi
 
-echo "Using ${HEAP_SIZE}MB heap (${AVAILABLE_MEM}MB available)" >&2
+# Calculate code cache (much smaller)
+CODE_CACHE_SIZE=$((HEAP_SIZE / 2))
+if [ "$CODE_CACHE_SIZE" -lt 2 ]; then
+    CODE_CACHE_SIZE=2
+fi
 
-# Execute Java with calculated settings
-exec java -Xms1m -Xmx${HEAP_SIZE}m -Djava.awt.headless=true "$@"
+echo "Using ${HEAP_SIZE}MB heap, ${CODE_CACHE_SIZE}MB code cache (${AVAILABLE_MEM}MB available)" >&2
+
+# Execute Java with all memory limits
+exec java \\
+    -Xms1m \\
+    -Xmx${HEAP_SIZE}m \\
+    -XX:ReservedCodeCacheSize=${CODE_CACHE_SIZE}m \\
+    -XX:InitialCodeCacheSize=1m \\
+    -XX:+UseSerialGC \\
+    -XX:MaxMetaspaceSize=8m \\
+    -XX:CompressedClassSpaceSize=4m \\
+    -Xss128k \\
+    -XX:-TieredCompilation \\
+    -Djava.awt.headless=true \\
+    "$@"
 """
         
         wrapper_path = os.path.join(workspace, "java_wrapper.sh")
@@ -583,91 +600,133 @@ exec java -Xms1m -Xmx${HEAP_SIZE}m -Djava.awt.headless=true "$@"
         workspace: str,
         input_data: Optional[List[str]] = None,
     ) -> ExecutionResult:
-        """Execute Java using a memory-aware wrapper script"""
+        """Execute Java using a memory-aware wrapper script with fallback"""
         
-        try:
-            # Create wrapper script
-            wrapper_path = await self._create_java_wrapper(workspace)
+        # Try wrapper first, then fallback to minimal direct execution
+        approaches = [
+            ("wrapper", None),
+            ("minimal", ["-Xms1m", "-Xmx8m", "-Djava.awt.headless=true"]),
+            ("ultra_minimal", ["-Xms1m", "-Xmx4m", "-Djava.awt.headless=true"]),
+            ("no_limits", ["-Djava.awt.headless=true"])
+        ]
+        
+        for approach_name, jvm_opts in approaches:
+            logger.info(f"Trying Java execution approach: {approach_name}")
             
-            results = []
-            for main_file in main_files:
-                # Determine class name
-                if main_file.endswith(".class"):
-                    class_name = main_file.replace(".class", "")
-                elif main_file.endswith(".java"):
-                    class_name = main_file.replace(".java", "")
+            try:
+                if approach_name == "wrapper":
+                    # Create and use wrapper script
+                    wrapper_path = await self._create_java_wrapper(workspace)
+                    result = await self._try_java_direct(main_files, workspace, input_data, wrapper_cmd=wrapper_path)
                 else:
-                    class_name = main_file
+                    # Use direct java with specific JVM options
+                    result = await self._try_java_direct(main_files, workspace, input_data, jvm_opts=jvm_opts)
+                
+                # If successful or not a memory error, return result
+                if result.success or "Could not reserve" not in result.stderr:
+                    logger.info(f"Java execution successful with approach: {approach_name}")
+                    return result
+                else:
+                    logger.warning(f"Approach {approach_name} failed with memory error, trying next...")
+                    
+            except Exception as e:
+                logger.warning(f"Approach {approach_name} failed with exception: {e}")
+                continue
+        
+        # If all approaches fail
+        return ExecutionResult(
+            success=False,
+            stdout="",
+            stderr="Java execution failed with all memory configurations. Container memory too limited for JVM.",
+            execution_time=0,
+            exit_code=-1,
+            error="All JVM memory configurations failed"
+        )
 
-                # Verify the .class file exists
-                class_file_path = os.path.join(workspace, f"{class_name}.class")
-                if not os.path.exists(class_file_path):
-                    results.append(
-                        ExecutionResult(
-                            success=False,
-                            stdout="",
-                            stderr=f"Class file not found: {class_name}.class",
-                            execution_time=0,
-                            exit_code=-1,
-                        )
+    async def _try_java_direct(
+        self,
+        main_files: List[str],
+        workspace: str,
+        input_data: Optional[List[str]],
+        wrapper_cmd: Optional[str] = None,
+        jvm_opts: Optional[List[str]] = None
+    ) -> ExecutionResult:
+        """Try Java execution with specific configuration"""
+        
+        results = []
+        for main_file in main_files:
+            # Determine class name
+            if main_file.endswith(".class"):
+                class_name = main_file.replace(".class", "")
+            elif main_file.endswith(".java"):
+                class_name = main_file.replace(".java", "")
+            else:
+                class_name = main_file
+
+            # Verify the .class file exists
+            class_file_path = os.path.join(workspace, f"{class_name}.class")
+            if not os.path.exists(class_file_path):
+                results.append(
+                    ExecutionResult(
+                        success=False,
+                        stdout="",
+                        stderr=f"Class file not found: {class_name}.class",
+                        execution_time=0,
+                        exit_code=-1,
                     )
-                    continue
+                )
+                continue
 
-                try:
-                    start_time = asyncio.get_event_loop().time()
+            try:
+                start_time = asyncio.get_event_loop().time()
 
-                    # Use wrapper script instead of direct java
-                    java_cmd = [wrapper_path, class_name]
-                    
-                    stdout, stderr, returncode = await self._execute_with_input(
-                        java_cmd, workspace, input_data
-                    )
+                # Build command
+                if wrapper_cmd:
+                    java_cmd = [wrapper_cmd, class_name]
+                elif jvm_opts:
+                    java_cmd = ["java"] + jvm_opts + [class_name]
+                else:
+                    java_cmd = ["java", class_name]
+                
+                stdout, stderr, returncode = await self._execute_with_input(
+                    java_cmd, workspace, input_data
+                )
 
-                    execution_time = asyncio.get_event_loop().time() - start_time
+                execution_time = asyncio.get_event_loop().time() - start_time
 
-                    results.append(
-                        ExecutionResult(
-                            success=returncode == 0,
-                            stdout=stdout.decode("utf-8", errors="replace"),
-                            stderr=stderr.decode("utf-8", errors="replace"),
-                            execution_time=execution_time,
-                            exit_code=returncode,
-                        )
+                results.append(
+                    ExecutionResult(
+                        success=returncode == 0,
+                        stdout=stdout.decode("utf-8", errors="replace"),
+                        stderr=stderr.decode("utf-8", errors="replace"),
+                        execution_time=execution_time,
+                        exit_code=returncode,
                     )
+                )
 
-                except asyncio.TimeoutError:
-                    results.append(
-                        ExecutionResult(
-                            success=False,
-                            stdout="",
-                            stderr="Execution timeout exceeded",
-                            execution_time=MAX_EXECUTION_TIME,
-                            exit_code=-1,
-                        )
+            except asyncio.TimeoutError:
+                results.append(
+                    ExecutionResult(
+                        success=False,
+                        stdout="",
+                        stderr="Execution timeout exceeded",
+                        execution_time=MAX_EXECUTION_TIME,
+                        exit_code=-1,
                     )
-                except Exception as e:
-                    results.append(
-                        ExecutionResult(
-                            success=False,
-                            stdout="",
-                            stderr=str(e),
-                            execution_time=0,
-                            exit_code=-1,
-                            error=str(e),
-                        )
+                )
+            except Exception as e:
+                results.append(
+                    ExecutionResult(
+                        success=False,
+                        stdout="",
+                        stderr=str(e),
+                        execution_time=0,
+                        exit_code=-1,
+                        error=str(e),
                     )
+                )
 
-            return self._combine_results(results, main_files)
-            
-        except Exception as e:
-            return ExecutionResult(
-                success=False,
-                stdout="",
-                stderr=f"Wrapper execution failed: {str(e)}",
-                execution_time=0,
-                exit_code=-1,
-                error=str(e),
-            )
+        return self._combine_results(results, main_files)
 
     async def _execute_c_cpp(
         self,