Update app.py

app.py

@@ -71,6 +71,72 @@ class CodeExecutor:
             )
             resource.setrlimit(resource.RLIMIT_AS, (MAX_MEMORY, MAX_MEMORY))
 
+    def check_available_memory(self) -> int:
+        """Check available memory in MB"""
+        try:
+            with open('/proc/meminfo', 'r') as f:
+                meminfo = f.read()
+                
+            available_match = re.search(r'MemAvailable:\s+(\d+)\s+kB', meminfo)
+            if available_match:
+                available_kb = int(available_match.group(1))
+                available_mb = available_kb // 1024
+                logger.info(f"Available memory: {available_mb}MB")
+                return available_mb
+            
+            # Fallback to MemFree + Cached
+            free_match = re.search(r'MemFree:\s+(\d+)\s+kB', meminfo)
+            cached_match = re.search(r'Cached:\s+(\d+)\s+kB', meminfo)
+            
+            if free_match and cached_match:
+                free_kb = int(free_match.group(1))
+                cached_kb = int(cached_match.group(1))
+                available_mb = (free_kb + cached_kb) // 1024
+                logger.info(f"Estimated available memory: {available_mb}MB")
+                return available_mb
+                
+        except Exception as e:
+            logger.warning(f"Could not check memory: {e}")
+            
+        return 0  # Unknown
+
+    async def _create_java_wrapper(self, workspace: str) -> str:
+        """Create a wrapper script for Java execution with better memory handling"""
+        
+        wrapper_script = """#!/bin/bash
+# Java memory wrapper for container environments
+
+# Get available memory
+AVAILABLE_MEM=$(awk '/MemAvailable/ {print int($2/1024)}' /proc/meminfo 2>/dev/null || echo "32")
+
+if [ "$AVAILABLE_MEM" -lt 20 ]; then
+    echo "Error: Insufficient memory available ($AVAILABLE_MEM MB)" >&2
+    exit 1
+fi
+
+# Calculate heap size (30% of available, min 4MB, max 12MB)
+HEAP_SIZE=$((AVAILABLE_MEM * 30 / 100))
+if [ "$HEAP_SIZE" -lt 4 ]; then
+    HEAP_SIZE=4
+elif [ "$HEAP_SIZE" -gt 12 ]; then
+    HEAP_SIZE=12
+fi
+
+echo "Using ${HEAP_SIZE}MB heap (${AVAILABLE_MEM}MB available)" >&2
+
+# Execute Java with calculated settings
+exec java -Xms1m -Xmx${HEAP_SIZE}m -Djava.awt.headless=true "$@"
+"""
+        
+        wrapper_path = os.path.join(workspace, "java_wrapper.sh")
+        with open(wrapper_path, 'w') as f:
+            f.write(wrapper_script)
+        
+        # Make executable
+        os.chmod(wrapper_path, 0o755)
+        
+        return wrapper_path
+
     def analyze_input_patterns(
         self, language: str, file_contents: Dict[str, str]
     ) -> InputAnalysisResult:
@@ -459,28 +525,12 @@ class CodeExecutor:
         java_files = list(Path(workspace).glob("*.java"))
         needs_compilation = len(java_files) > 0
     
-        # JVM options for very limited container environment (HuggingFace)
-        jvm_opts = [
-            "-Xms8m",                        # Minimal initial heap
-            "-Xmx64m",                       # Very small max heap
-            "-XX:ReservedCodeCacheSize=8m",  # Minimal code cache
-            "-XX:InitialCodeCacheSize=1m",   # Tiny initial code cache
-            "-XX:+UseSerialGC",              # Simple GC
-            "-XX:NewRatio=3",                # Small young generation
-            "-XX:SurvivorRatio=4",           # Optimize survivor space
-            "-XX:MaxMetaspaceSize=32m",      # Limit metaspace
-            "-XX:CompressedClassSpaceSize=8m", # Compress class space
-            "-Xss256k",                      # Small stack size
-            "-XX:-TieredCompilation",        # Disable tiered compilation to save memory
-            "-Djava.awt.headless=true",      # Headless mode
-        ]
-    
         # If we have .java files, compile them
         if needs_compilation:
             logger.info(f"Found {len(java_files)} Java source files, compiling...")
     
-            # Compile with minimal memory for javac
-            compile_cmd = ["javac", "-J-Xmx32m", "-J-Xms8m"] + [str(f) for f in java_files]
+            # Compile with absolute minimal memory for javac
+            compile_cmd = ["javac", "-J-Xmx16m", "-J-Xms2m"] + [str(f) for f in java_files]
             
             compile_process = await asyncio.create_subprocess_exec(
                 *compile_cmd,
@@ -524,76 +574,100 @@ class CodeExecutor:
     
             logger.info("Using existing .class files, skipping compilation")
     
-        # Execute main files
-        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,
+        # Use memory-aware wrapper for execution
+        return await self._execute_java_with_wrapper(main_files, workspace, input_data)
+
+    async def _execute_java_with_wrapper(
+        self,
+        main_files: List[str],
+        workspace: str,
+        input_data: Optional[List[str]] = None,
+    ) -> ExecutionResult:
+        """Execute Java using a memory-aware wrapper script"""
+        
+        try:
+            # Create wrapper script
+            wrapper_path = await self._create_java_wrapper(workspace)
+            
+            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
-    
-            try:
-                start_time = asyncio.get_event_loop().time()
-    
-                # Build java command with memory optimization
-                java_cmd = ["java"] + jvm_opts + [class_name]
-                
-                stdout, stderr, returncode = await self._execute_with_input(
-                    java_cmd, workspace, input_data
-                )
-    
-                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,
+                    continue
+
+                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
                     )
-                )
-    
-            except asyncio.TimeoutError:
-                results.append(
-                    ExecutionResult(
-                        success=False,
-                        stdout="",
-                        stderr="Execution timeout exceeded",
-                        execution_time=MAX_EXECUTION_TIME,
-                        exit_code=-1,
+
+                    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,
+                        )
                     )
-                )
-            except Exception as e:
-                results.append(
-                    ExecutionResult(
-                        success=False,
-                        stdout="",
-                        stderr=str(e),
-                        execution_time=0,
-                        exit_code=-1,
-                        error=str(e),
+
+                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),
+                        )
                     )
-                )
-    
-        return self._combine_results(results, main_files)
+
+            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),
+            )
 
     async def _execute_c_cpp(
         self,
@@ -836,6 +910,12 @@ def detect_language_from_files(main_files: List[str]) -> str:
     return detected_language
 
 
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "timestamp": asyncio.get_event_loop().time()}
+
+
 @app.post("/analyze-inputs")
 async def analyze_inputs(code_content: str = Form(...), language: str = Form(...)):
     """
@@ -1065,4 +1145,4 @@ input("Press enter to continue...")
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run("app_3:app", host="0.0.0.0", port=8000, reload=True)
+    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)