Update XZ Utils to 5.0.3 (in deps)

src/xz/hardware.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       hardware.c
 /// \brief      Detection of available hardware resources
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "private.h"
 #include "tuklib_cpucores.h"
 
 
 /// Maximum number of free *coder* threads. This can be set with
 /// the --threads=NUM command line option.
 static uint32_t threadlimit;
 
-/// Memory usage limit
-static uint64_t memlimit;
+/// Memory usage limit for compression
+static uint64_t memlimit_compress;
+
+/// Memory usage limit for decompression
+static uint64_t memlimit_decompress;
 
 /// Total amount of physical RAM
 static uint64_t total_ram;
 
 
 extern void
 hardware_threadlimit_set(uint32_t new_threadlimit)
 {
         if (new_threadlimit == 0) {
                 // The default is the number of available CPU cores.
                 threadlimit = tuklib_cpucores();
                 if (threadlimit == 0)
                         threadlimit = 1;
         } else {
                 threadlimit = new_threadlimit;
         }
 
         return;
 }
 
 
 extern uint32_t
 hardware_threadlimit_get(void)
 {
         return threadlimit;
 }
 
 
 extern void
-hardware_memlimit_set(uint64_t new_memlimit)
+hardware_memlimit_set(uint64_t new_memlimit,
+                bool set_compress, bool set_decompress, bool is_percentage)
 {
-        if (new_memlimit != 0) {
-                memlimit = new_memlimit;
-        } else {
-                // The default depends on the amount of RAM but so that
-                // on "low-memory" systems the relative limit is higher
-                // to make it more likely that files created with "xz -9"
-                // will still decompress without overriding the limit
-                // manually.
-                //
-                // If 40 % of RAM is 80 MiB or more, use 40 % of RAM as
-                // the limit.
-                memlimit = 40 * total_ram / 100;
-                if (memlimit < UINT64_C(80) * 1024 * 1024) {
-                        // If 80 % of RAM is less than 80 MiB,
-                        // use 80 % of RAM as the limit.
-                        memlimit = 80 * total_ram / 100;
-                        if (memlimit > UINT64_C(80) * 1024 * 1024) {
-                                // Otherwise use 80 MiB as the limit.
-                                memlimit = UINT64_C(80) * 1024 * 1024;
-                        }
-                }
+        if (is_percentage) {
+                assert(new_memlimit > 0);
+                assert(new_memlimit <= 100);
+                new_memlimit = (uint32_t)new_memlimit * total_ram / 100;
         }
 
+        if (set_compress)
+                memlimit_compress = new_memlimit;
+
+        if (set_decompress)
+                memlimit_decompress = new_memlimit;
+
+        return;
+}
+
+
+extern uint64_t
+hardware_memlimit_get(enum operation_mode mode)
+{
+        // Zero is a special value that indicates the default. Currently
+        // the default simply disables the limit. Once there is threading
+        // support, this might be a little more complex, because there will
+        // probably be a special case where a user asks for "optimal" number
+        // of threads instead of a specific number (this might even become
+        // the default mode). Each thread may use a significant amount of
+        // memory. When there are no memory usage limits set, we need some
+        // default soft limit for calculating the "optimal" number of
+        // threads.
+        const uint64_t memlimit = mode == MODE_COMPRESS
+                        ? memlimit_compress : memlimit_decompress;
+        return memlimit != 0 ? memlimit : UINT64_MAX;
+}
+
+
+/// Helper for hardware_memlimit_show() to print one human-readable info line.
+static void
+memlimit_show(const char *str, uint64_t value)
+{
+        // The memory usage limit is considered to be disabled if value
+        // is 0 or UINT64_MAX. This might get a bit more complex once there
+        // is threading support. See the comment in hardware_memlimit_get().
+        if (value == 0 || value == UINT64_MAX)
+                printf("%s %s\n", str, _("Disabled"));
+        else
+                printf("%s %s MiB (%s B)\n", str,
+                                uint64_to_str(round_up_to_mib(value), 0),
+                                uint64_to_str(value, 1));
+
         return;
 }
 
 
 extern void
-hardware_memlimit_set_percentage(uint32_t percentage)
+hardware_memlimit_show(void)
 {
-        assert(percentage > 0);
-        assert(percentage <= 100);
+        if (opt_robot) {
+                printf("%" PRIu64 "\t%" PRIu64 "\t%" PRIu64 "\n", total_ram,
+                                memlimit_compress, memlimit_decompress);
+        } else {
+                // TRANSLATORS: Test with "xz --info-memory" to see if
+                // the alignment looks nice.
+                memlimit_show(_("Total amount of physical memory (RAM): "),
+                                total_ram);
+                memlimit_show(_("Memory usage limit for compression:    "),
+                                memlimit_compress);
+                memlimit_show(_("Memory usage limit for decompression:  "),
+                                memlimit_decompress);
+        }
 
-        memlimit = percentage * total_ram / 100;
-        return;
+        tuklib_exit(E_SUCCESS, E_ERROR, message_verbosity_get() != V_SILENT);
 }
 
 
-extern uint64_t
-hardware_memlimit_get(void)
-{
-        return memlimit;
-}
-
-
 extern void
 hardware_init(void)
 {
         // Get the amount of RAM. If we cannot determine it,
         // use the assumption defined by the configure script.
         total_ram = lzma_physmem();
         if (total_ram == 0)
                 total_ram = (uint64_t)(ASSUME_RAM) * 1024 * 1024;
 
         // Set the defaults.
-        hardware_memlimit_set(0);
+        hardware_memlimit_set(0, true, true, false);
         hardware_threadlimit_set(0);
         return;
 }