Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e535eeb in mainline


Ignore:
Timestamp:
2010-04-18T12:28:19Z (13 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial
Children:
dec16a2
Parents:
e1b6742
Message:

rename order() to order_suffix(), make it a generic libc string function in user space

Files:
4 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/func.h

    re1b6742 re535eeb  
    4343extern void halt(void) __attribute__((noreturn));
    4444extern unative_t atoi(const char *text);
    45 extern void order(const uint64_t val, uint64_t *rv, char *suffix);
    4645
    4746#endif
  • kernel/generic/include/str.h

    re1b6742 re535eeb  
    9999extern int str_uint64(const char *, char **, unsigned int, bool, uint64_t *);
    100100
     101extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
     102
    101103#endif
    102104
  • kernel/generic/src/console/cmd.c

    re1b6742 re535eeb  
    10681068        uint64_t ucycles, kcycles;
    10691069        char usuffix, ksuffix;
    1070         order(ucycles1 - ucycles0, &ucycles, &usuffix);
    1071         order(kcycles1 - kcycles0, &kcycles, &ksuffix);
     1070        order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
     1071        order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    10721072               
    10731073        printf("Time: %" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles\n",
     
    11301130               
    11311131                data[i] = ucycles1 - ucycles0 + kcycles1 - kcycles0;
    1132                 order(ucycles1 - ucycles0, &ucycles, &usuffix);
    1133                 order(kcycles1 - kcycles0, &kcycles, &ksuffix);
     1132                order_suffix(ucycles1 - ucycles0, &ucycles, &usuffix);
     1133                order_suffix(kcycles1 - kcycles0, &kcycles, &ksuffix);
    11341134                printf("OK (%" PRIu64 "%c user cycles, %" PRIu64 "%c kernel cycles)\n",
    11351135                                ucycles, usuffix, kcycles, ksuffix);
     
    11451145                }
    11461146               
    1147                 order(sum / (uint64_t) cnt, &ucycles, &usuffix);
     1147                order_suffix(sum / (uint64_t) cnt, &ucycles, &usuffix);
    11481148                printf("Average\t\t%" PRIu64 "%c\n", ucycles, usuffix);
    11491149        }
  • kernel/generic/src/lib/func.c

    re1b6742 re535eeb  
    123123}
    124124
    125 
    126 void order(const uint64_t val, uint64_t *rv, char *suffix)
    127 {
    128         if (val > 10000000000000000000ULL) {
    129                 *rv = val / 1000000000000000000ULL;
    130                 *suffix = 'Z';
    131         } else if (val > 1000000000000000000ULL) {
    132                 *rv = val / 1000000000000000ULL;
    133                 *suffix = 'E';
    134         } else if (val > 1000000000000000ULL) {
    135                 *rv = val / 1000000000000ULL;
    136                 *suffix = 'T';
    137         } else if (val > 1000000000000ULL) {
    138                 *rv = val / 1000000000ULL;
    139                 *suffix = 'G';
    140         } else if (val > 1000000000ULL) {
    141                 *rv = val / 1000000ULL;
    142                 *suffix = 'M';
    143         } else if (val > 1000000ULL) {
    144                 *rv = val / 1000ULL;
    145                 *suffix = 'k';
    146         } else {
    147                 *rv = val;
    148                 *suffix = ' ';
    149         }
    150 }
    151 
    152125/** @}
    153126 */
  • kernel/generic/src/lib/str.c

    re1b6742 re535eeb  
    918918}
    919919
     920void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
     921{
     922        if (val > 10000000000000000000ULL) {
     923                *rv = val / 1000000000000000000ULL;
     924                *suffix = 'Z';
     925        } else if (val > 1000000000000000000ULL) {
     926                *rv = val / 1000000000000000ULL;
     927                *suffix = 'E';
     928        } else if (val > 1000000000000000ULL) {
     929                *rv = val / 1000000000000ULL;
     930                *suffix = 'T';
     931        } else if (val > 1000000000000ULL) {
     932                *rv = val / 1000000000ULL;
     933                *suffix = 'G';
     934        } else if (val > 1000000000ULL) {
     935                *rv = val / 1000000ULL;
     936                *suffix = 'M';
     937        } else if (val > 1000000ULL) {
     938                *rv = val / 1000ULL;
     939                *suffix = 'k';
     940        } else {
     941                *rv = val;
     942                *suffix = ' ';
     943        }
     944}
     945
    920946/** @}
    921947 */
  • kernel/generic/src/proc/task.c

    re1b6742 re535eeb  
    432432        char usuffix, ksuffix;
    433433        task_get_accounting(t, &ucycles, &kcycles);
    434         order(ucycles, &ucycles, &usuffix);
    435         order(kcycles, &kcycles, &ksuffix);
     434        order_suffix(ucycles, &ucycles, &usuffix);
     435        order_suffix(kcycles, &kcycles, &ksuffix);
    436436       
    437437#ifdef __32_BITS__     
  • kernel/generic/src/proc/thread.c

    re1b6742 re535eeb  
    5050#include <synch/rwlock.h>
    5151#include <cpu.h>
    52 #include <func.h>
     52#include <str.h>
    5353#include <context.h>
    5454#include <adt/avl.h>
     
    626626        uint64_t ucycles, kcycles;
    627627        char usuffix, ksuffix;
    628         order(t->ucycles, &ucycles, &usuffix);
    629         order(t->kcycles, &kcycles, &ksuffix);
     628        order_suffix(t->ucycles, &ucycles, &usuffix);
     629        order_suffix(t->kcycles, &kcycles, &ksuffix);
    630630
    631631#ifdef __32_BITS__
  • uspace/app/tasks/Makefile

    re1b6742 re535eeb  
    3232
    3333SOURCES = \
    34         tasks.c \
    35         func.c
     34        tasks.c
    3635
    3736include $(USPACE_PREFIX)/Makefile.common
  • uspace/app/tasks/tasks.c

    re1b6742 re535eeb  
    4545#include <inttypes.h>
    4646#include <bool.h>
     47#include <str.h>
    4748#include <arg_parse.h>
    48 #include "func.h"
    4949
    5050#define NAME  "tasks"
     
    7676                        char vmsuffix, usuffix, ksuffix;
    7777                       
    78                         order(stats_task->virtmem, &virtmem, &vmsuffix);
    79                         order(stats_task->ucycles, &ucycles, &usuffix);
    80                         order(stats_task->kcycles, &kcycles, &ksuffix);
     78                        order_suffix(stats_task->virtmem, &virtmem, &vmsuffix);
     79                        order_suffix(stats_task->ucycles, &ucycles, &usuffix);
     80                        order_suffix(stats_task->kcycles, &kcycles, &ksuffix);
    8181                       
    8282                        printf("%8" PRIu64 "%8u %8" PRIu64"%c %12"
     
    113113                                char usuffix, ksuffix;
    114114                               
    115                                 order(stats_thread->ucycles, &ucycles, &usuffix);
    116                                 order(stats_thread->kcycles, &kcycles, &ksuffix);
     115                                order_suffix(stats_thread->ucycles, &ucycles, &usuffix);
     116                                order_suffix(stats_thread->kcycles, &kcycles, &ksuffix);
    117117                               
    118118                                if (stats_thread->on_cpu) {
  • uspace/app/top/Makefile

    re1b6742 re535eeb  
    3535        screen.c \
    3636        input.c \
    37         func.c \
    3837        ps.c
    3938
  • uspace/lib/c/generic/str.c

    re1b6742 re535eeb  
    10071007}
    10081008
     1009void order_suffix(const uint64_t val, uint64_t *rv, char *suffix)
     1010{
     1011        if (val > 10000000000000000000ULL) {
     1012                *rv = val / 1000000000000000000ULL;
     1013                *suffix = 'Z';
     1014        } else if (val > 1000000000000000000ULL) {
     1015                *rv = val / 1000000000000000ULL;
     1016                *suffix = 'E';
     1017        } else if (val > 1000000000000000ULL) {
     1018                *rv = val / 1000000000000ULL;
     1019                *suffix = 'T';
     1020        } else if (val > 1000000000000ULL) {
     1021                *rv = val / 1000000000ULL;
     1022                *suffix = 'G';
     1023        } else if (val > 1000000000ULL) {
     1024                *rv = val / 1000000ULL;
     1025                *suffix = 'M';
     1026        } else if (val > 1000000ULL) {
     1027                *rv = val / 1000ULL;
     1028                *suffix = 'k';
     1029        } else {
     1030                *rv = val;
     1031                *suffix = ' ';
     1032        }
     1033}
     1034
    10091035/** @}
    10101036 */
  • uspace/lib/c/include/str.h

    re1b6742 re535eeb  
    8686extern char *str_ndup(const char *, size_t max_size);
    8787
     88extern void order_suffix(const uint64_t val, uint64_t *rv, char *suffix);
     89
    8890/*
    8991 * TODO: Get rid of this.
Note: See TracChangeset for help on using the changeset viewer.