Attempt to set a 'soft minimum' of 4GB during decompile.

Author: LexManos

src/main/java/net/minecraftforge/mcmaven/impl/Mavenizer.java

@@ -104,7 +104,7 @@ public static void setDecompileMemory(String value) {
     // https://github.com/openjdk/jdk/blob/08c8520b39083ec6354dc5df2f18c1f4c3588053/src/hotspot/share/runtime/arguments.cpp#L3628
     private static final String[] DEFAULT_ARG_ENV = { "JAVA_OPTIONS", "_JAVA_OPTIONS", "JAVA_TOOL_OPIONS"};
     private static final String[] MEMORY_FLAGS = {"-Xmx", "-XX:MaxHeapSize", "-Xms"};
-    private static void warnAboutMemory() {
+    private static boolean warnAboutMemory() {
         var found = false;
         for (var env : DEFAULT_ARG_ENV) {
             var value = System.getenv(env);
@@ -119,9 +119,10 @@ private static void warnAboutMemory() {
         }
         if (found)
             LOGGER.warn("Please remove it if you run into memory related issues");
+        return found;
     }
 
-    public static List<String> fillDecompileJvmArgs(List<String> args, boolean firstRun) {
+    public static List<String> fillDecompileJvmArgs(List<String> args, boolean firstRun, boolean useDefaultGuess) {
         if (!firstRun)
             return args; // Use the unmodifed args from MCPConfig
 
@@ -135,8 +136,14 @@ public static List<String> fillDecompileJvmArgs(List<String> args, boolean first
             //     https://docs.oracle.com/en/java/javase/21/gctuning/ergonomics.html
             // There are old JVMs that limit it to 1GB but there is no good way to detect if we're using one so just hope.
             //     https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/ergonomics.html
-            // Best we can do is warn about memory argumetns if we see them.
+            // Best we can do is warn about memory arguments if we see them.
             warnAboutMemory();
+
+            // Lets try and pick a 'sensible' default minimum size, this number is arbitrary, and causes issues with systems with low amounts of ram
+            // I really hate just setting an arbitrary lower limit
+            // If someone has a better idea how to deal with this feel free to submit it.
+            if (useDefaultGuess)
+                ret.add("-Xms4G");
         }
         return ret;
     }

src/main/java/net/minecraftforge/mcmaven/impl/repo/mcpconfig/MCPTaskFactory.java

@@ -834,19 +834,27 @@ private File execute(String name, List<TaskOrArg> jvmArgs, List<TaskOrArg> runAr
 
         ToIntFunction<String> logHandler = null;
         if (isDecompile) {
-            jvm = Mavenizer.fillDecompileJvmArgs(jvm, true);
+            jvm = Mavenizer.fillDecompileJvmArgs(jvm, true, true);
             logHandler = MCPTaskFactory::parseDecompileLog;
         }
 
         var ret = ProcessUtils.runJar(jdk, log.getParentFile(), log, tool, jvm, run, logHandler);
-        if (ret.exitCode == OUT_OF_MEMORY && isDecompile) {
-            var newJvm = Mavenizer.fillDecompileJvmArgs(resolveArgs(cache, tasks, jvmArgs), false);
-            if (!newJvm.equals(jvm)) {
-                LOGGER.error("First decompile failed with OutOfMemory using JVM Args: " + jvm);
-                LOGGER.error("Attempting again with: " + newJvm);
-                ret = ProcessUtils.runJar(jdk, log.getParentFile(), log, tool, newJvm, run, logHandler);
-                if (ret.exitCode == OUT_OF_MEMORY)
-                    LOGGER.error("Ran out of memory again, you can specify more manually using the --decompile-memory Mavenizer argument");
+        if (isDecompile) {
+            if (ret.exitCode == NOT_ENOUGH_MEMORY) {
+                LOGGER.error("Failed to create JVM with Not Enough Memory issue, Modern minecraft requires atleast 4GB to decompile. Run it on a system with more ram.");
+            } else if (ret.exitCode == INVALID_INITAL_HEAP) {
+                LOGGER.error("Attempted to run decompile with JVM args: " + jvm + " resulted in Invalid Inital and Max heap settings.");
+                LOGGER.error("This is typically caused by you having a environement variable setting the global memory options, remove or set those variables to values higher then 4GB.");
+            }
+            if (ret.exitCode == OUT_OF_MEMORY || ret.exitCode == INVALID_INITAL_HEAP) {
+                var newJvm = Mavenizer.fillDecompileJvmArgs(resolveArgs(cache, tasks, jvmArgs), false, false);
+                if (!newJvm.equals(jvm)) {
+                    LOGGER.error("First decompile failed with OutOfMemory using JVM Args: " + jvm);
+                    LOGGER.error("Attempting again with: " + newJvm);
+                    ret = ProcessUtils.runJar(jdk, log.getParentFile(), log, tool, newJvm, run, logHandler);
+                    if (ret.exitCode == OUT_OF_MEMORY)
+                        LOGGER.error("Ran out of memory again, you can specify more manually using the --decompile-memory Mavenizer argument");
+                }
             }
         }
         if (ret.exitCode != 0)
@@ -904,10 +912,16 @@ private List<String> resolveArgs(HashStore cache, Map<Task, String> tasks, List<
 
     private static final int OUT_OF_MEMORY = -1001;
     private static final int FAILED_DECOMPILE = -1002;
+    private static final int INVALID_INITAL_HEAP = -1003;
+    private static final int NOT_ENOUGH_MEMORY = -1004;
     // Yes this is slow as fuck, but this is only run during a decompile run which is already slow,
     // This is to check if Fernflower is broken and returning success when it really failed.
     // It also eagerly exits the process when something fails so as to not waste time.
     private static int parseDecompileLog(String line) {
+        if (line.startsWith("Initial heap size set to a larger value than the maximum heap size"))
+            return INVALID_INITAL_HEAP;
+        if (line.startsWith("Could not reserve enough space for object heap"))
+            return NOT_ENOUGH_MEMORY;
         if (line.startsWith("java.lang.OutOfMemoryError:"))
             return OUT_OF_MEMORY;
         if (line.startsWith("Exception in thread") && line.contains("java.lang.OutOfMemoryError"))