Changeset 933cadf in mainline for kernel

Timestamp:

2011-04-22T13:35:41Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

3dbe4ca2, afdcc60e, b678410

Parents:

74c8f344

Message:

use binary suffixes in printouts where appropriate

Location:

kernel

Files:

• arch/mips32/src/mm/frame.c (modified) (1 diff)
• generic/include/macros.h (modified) (1 diff)
• generic/include/str.h (modified) (1 diff)
• generic/src/lib/str.c (modified) (2 diffs)
• generic/src/main/main.c (modified) (1 diff)
• generic/src/mm/frame.c (modified) (3 diffs)

kernel/arch/mips32/src/mm/frame.c

@@ -88 +88 @@
         /* gxemul devices */
         if (overlaps(frame << ZERO_PAGE_WIDTH, ZERO_PAGE_SIZE,
-            0x10000000, MB2SIZE(256)))
+            0x10000000, MiB2SIZE(256)))
                 return false;
 #endif

kernel/generic/include/macros.h

@@ -95 +95 @@
         overlaps(KA2PA((x)), (szx), KA2PA((y)), (szy))
 
-#define SIZE2KB(size)  ((size) >> 10)
-#define SIZE2MB(size)  ((size) >> 20)
-
-#define KB2SIZE(kb)  ((kb) << 10)
-#define MB2SIZE(mb)  ((mb) << 20)
+#define KiB2SIZE(kb)  ((kb) << 10)
+#define MiB2SIZE(mb)  ((mb) << 20)
 
 #define STRING(arg)      STRING_ARG(arg)

kernel/generic/include/str.h

@@ -99 +99 @@
 extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
 
-extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
+extern void order_suffix(const uint64_t, uint64_t *, char *);
+extern void bin_order_suffix(const uint64_t, uint64_t *, const char **, bool);
 
 #endif

kernel/generic/src/lib/str.c

@@ -922 +922 @@
 void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
 {
-        if (val > 10000000000000000000ULL) {
-                *rv = val / 1000000000000000000ULL;
+        if (val > UINT64_C(10000000000000000000)) {
+                *rv = val / UINT64_C(1000000000000000000);
                 *suffix = 'Z';
-        } else if (val > 1000000000000000000ULL) {
-                *rv = val / 1000000000000000ULL;
+        } else if (val > UINT64_C(1000000000000000000)) {
+                *rv = val / UINT64_C(1000000000000000);
                 *suffix = 'E';
-        } else if (val > 1000000000000000ULL) {
-                *rv = val / 1000000000000ULL;
+        } else if (val > UINT64_C(1000000000000000)) {
+                *rv = val / UINT64_C(1000000000000);
                 *suffix = 'T';
-        } else if (val > 1000000000000ULL) {
-                *rv = val / 1000000000ULL;
+        } else if (val > UINT64_C(1000000000000)) {
+                *rv = val / UINT64_C(1000000000);
                 *suffix = 'G';
-        } else if (val > 1000000000ULL) {
-                *rv = val / 1000000ULL;
+        } else if (val > UINT64_C(1000000000)) {
+                *rv = val / UINT64_C(1000000);
                 *suffix = 'M';
-        } else if (val > 1000000ULL) {
-                *rv = val / 1000ULL;
+        } else if (val > UINT64_C(1000000)) {
+                *rv = val / UINT64_C(1000);
                 *suffix = 'k';
         } else {
@@ -946 +946 @@
 }
 
+void bin_order_suffix(const uint64_t val, uint64_t *rv, const char **suffix,
+    bool fixed)
+{
+        if (val > UINT64_C(1152921504606846976)) {
+                *rv = val / UINT64_C(1125899906842624);
+                *suffix = "EiB";
+        } else if (val > UINT64_C(1125899906842624)) {
+                *rv = val / UINT64_C(1099511627776);
+                *suffix = "TiB";
+        } else if (val > UINT64_C(1099511627776)) {
+                *rv = val / UINT64_C(1073741824);
+                *suffix = "GiB";
+        } else if (val > UINT64_C(1073741824)) {
+                *rv = val / UINT64_C(1048576);
+                *suffix = "MiB";
+        } else if (val > UINT64_C(1048576)) {
+                *rv = val / UINT64_C(1024);
+                *suffix = "KiB";
+        } else {
+                *rv = val;
+                if (fixed)
+                        *suffix = "B  ";
+                else
+                        *suffix = "B";
+        }
+}
+
 /** @}
  */

kernel/generic/src/main/main.c

@@ -223 +223 @@
         slab_enable_cpucache();
         
-        printf("Detected %u CPU(s), %" PRIu64 " MiB free memory\n",
-            config.cpu_count, SIZE2MB(zones_total_size()));
+        uint64_t size;
+        const char *size_suffix;
+        bin_order_suffix(zones_total_size(), &size, &size_suffix, false);
+        printf("Detected %u CPU(s), %" PRIu64 " %s free memory\n",
+            config.cpu_count, size, size_suffix);
         
         cpu_init();

kernel/generic/src/mm/frame.c

@@ -60 +60 @@
 #include <macros.h>
 #include <config.h>
+#include <str.h>
 
 zones_t zones;
@@ -1395 +1396 @@
         bool available = zone_flags_available(flags);
         
+        uint64_t size;
+        const char *size_suffix;
+        bin_order_suffix(FRAMES2SIZE(count), &size, &size_suffix, false);
+        
         printf("Zone number:       %zu\n", znum);
         printf("Zone base address: %p\n", (void *) base);
-        printf("Zone size:         %zu frames (%zu KiB)\n", count,
-            SIZE2KB(FRAMES2SIZE(count)));
+        printf("Zone size:         %zu frames (%" PRIu64 " %s)\n", count,
+            size, size_suffix);
         printf("Zone flags:        %c%c%c\n",
             available ? 'A' : ' ',
@@ -1405 +1410 @@
         
         if (available) {
-                printf("Allocated space:   %zu frames (%zu KiB)\n",
-                    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-                printf("Available space:   %zu frames (%zu KiB)\n",
-                    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
+                bin_order_suffix(FRAMES2SIZE(busy_count), &size, &size_suffix,
+                    false);
+                printf("Allocated space:   %zu frames (%" PRIu64 " %s)\n",
+                    busy_count, size, size_suffix);
+                bin_order_suffix(FRAMES2SIZE(free_count), &size, &size_suffix,
+                    false);
+                printf("Available space:   %zu frames (%" PRIu64 " %s)\n",
+                    free_count, size, size_suffix);
         }
 }