Optimalizálás: awk, grep, bármi?

Esetleg egy kisebb awk, ha létezik a jelenleginél kisebb. (ha gawk van felrakva, akkor a mawk szóba jöhet)
A grep-nek hogy adod meg, hogy csak a megfelelő mezőt írja ki?
A -o a teljes illeszkedő mintát kirakja, nem csak a numerikus részét. Vagy az nem gond?

Akit tudja, csinálja, aki nem tudja, tanítja... Hm... igazgatónak talán még jó lennék. :)

Nem szorosan a Te problémádra megoldás de másokat is foglalkoztat hasonló dolog. Ill. vannak munin pluginek is amik ezeket az adatokat gyűjtik. A fenti megoldásokat nem néztem végig, de háta van közöttük olyan ami segíthet, ötletet adhat.

Ennél egyszerűbben aligha lehetne megoldani, és ha mawk az az awk*, akkor gyorsabban se.
Illetve igen: megírod C-ben. Te tudod, hogy tényleg fut-e majd annyiszor, hogy megérje az ezzel töltött idő, másfelől viszont max. 20 sor a C változat, amit teszteléssel együtt 1 óra alatt össze lehet hozni.

*: mostanában előkerült ez a $munkahelyen: a mawk konzisztensen 2-5× gyorsabb volt a gawknál, cserébe előfordult, hogy elvileg portolható programnál sem viselkedett úgy, ahogy kellett volna.

Azt kell mondjam, hogy ezen sokat lehet gyorsítani - bár tisztában vagyok vele, hogy a bázis elég kicsi ahhoz, hogy a változás felszín alatt maradjon.

1.
Meg kéne adni, hogy hol található a keresett kifejezés.

Akár a

$1 == "privvmpages"

akár a

/^[[:space:]]+privvmpages/

vagy a

/^(a megfelelő mennyiségű szóköz ide leszámolva)+privvmpages/

megteszi. Érzésem szerint az első gyorsabb, de mind veri azt az esetet, amikor az egész regexppel végig kell túrni az egész sort.

2.
Ha sokszor fog futni, akkor nem biztos, hogy sokszor érdemes meghívni.

A getline ciklusba szervezésével (a close()-ról sem megfeledkezve) összehozható egy, az auto beolvasási mechanizmussal megegyező folyaamat. Már csak időzíteni kell. Nincs mese, erre a system("sleep N") adódik a legkevésbé duhajkodó eszköznek.

Lehet valamit rosszul nézek, de én grep-pel kevesebb hívást kapok.

strace -c awk '/MemFree/ {print $2}' /proc/meminfo

calls / errors = 92 / 7

strace -c grep MemFree /proc/meminfo | grep -oE "[0-9]+"

calls / errors = 60 / 8

Ja bocs, egyrészt mawk-kal nálam is 47 hívás, másrészt most látom hogy több numerikus oszlop van, azt már drága lenne kikapni - kivéve ha az utolsó szám kell.

strace mutatja a lib betolteseket is, kezdve pl. az /etc/ld.so.conf -fal.

Forditsd statikus awk-ot, ha zavar, az lejjebb viszi.

Masik lehetoseg folyamatos awk invokalas helyett egy folyamatosan futo processzt csinalni. gawk pl. tud getline-t, rakd bele egy '{while(1)}' ciklusba es jo vagy.

Vagy ha mar ugyis egy shell script fut, miert nem csinalod bash-ban? pl.

while read -a A; do
    echo $A[6]
done </proc/user_beancounters

man bash, v4.1 - v4.2 korul igen tapos boviteseket kapott am!

Lehet, hogy egy nagy hülyeséget írok, de vagy 10 évvel ezelőtt olvastam olyanról, hogy root jogokkal be lehet állítani, hogy bizonyos fájlok mindig a RAM-ban tárolt pufferben legyenek, onnan ne söpörje ki őket a kernel. Talán ha az awk és a hívott lib-ek ilyen módon lennének tárolva, akkor sosem kellene a merevlemezhez fordulni indításukkor, ami takaríthat meg időt. Persze, ha sűrűn vannak hívogatva, úgysem ürülnek ki a pufferből, úgyhogy nem biztos, hogy ez jó ötlet.

miert akarsz egy merhetetlen ideju taskot "optimalizalni"?

--
NetBSD - Simplicity is prerequisite for reliability


// fawk.c : minimalist awk


#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>

//returns index of a non-nul terminated substring within a non-nul terminated string
int str_idx(char* str, int str_len, char* substr, int substr_len)
{
    char* orig_str = str;

    while( substr_len <= str_len )
    {
        int i;
        for(i=0; i<substr_len; ++i)
        {
            if( str[i] != substr[i] )
                break;
        }

        if( i == substr_len )
            return str - orig_str;

        --str_len;
        ++str;
    }

    return -1;
}

int usage(int ret_code)
{
    printf(
        "usage: fawk <pattern> <column # to print> <input> [options]\n"
        "where\n"
        "   <pattern>             a word in quotes to search for in the columns - no regexp allowed\n"
        "   <column # to print>   serial of word to be printed\n"
        "   <input>               input file to read\n"
        " options:\n"
        "   --first_match_only    stops searching after the first match\n"
        "   --substring_match     the word is used as substring (default=exact match)\n"
        "\n"
        "example: fawk \"privvmpages\" 6 /proc/user_beancounters \n"
        );

    return ret_code;
}

int main(int argc, char* argv[])
{
    FILE* fi;
    int i;
    char line[4096+1];
    char* endp;

    int column_to_output;
    char* word_to_search_for;
    size_t word_to_search_len;
    int first_match_only = 0;
    int substring_match = 0;

    if( argc < 3 ) {
        printf("error: improper number of parameters\n");
        return usage(1);
    }

    word_to_search_for = argv[1];
    word_to_search_len = strlen(word_to_search_for);
    if( word_to_search_len <= 0 ) {
        printf("error: invalid word to search for: '%s'\n", argv[1]);
        return usage(2);
    }

    column_to_output = strtoul(argv[2], &endp, 10);
    if( endp == argv[2] || column_to_output < 0 ) {
        printf("error: invalid column number: '%s'\n", argv[2]);
        return usage(3);
    }

    for(i=4; i < argc; ++i)
    {
        if( strcmp(argv[i], "--first_match_only")==0 )
            first_match_only = 1;
        else if( strcmp(argv[i], "--substring_match")==0 )
            substring_match = 1;
    }

    fi = fopen(argv[3], "rt");
    if( !fi ) {
        printf("error: could not open input file '%s'\n", argv[3]);
        return usage(4);
    }

    while( fgets(line, sizeof(line), fi) )
    {
        char* p;
        size_t len;
        int word_num, match_found;
        char* word_to_output = NULL;
        size_t word_to_output_len = 0;

        line[sizeof(line)-1] = '\0';
        len = strlen(line);

        if( len > 0 && line[len-1] == '\n' )
            line[--len] = '\0';

        //if 0'th column requested, this means the whole line to be outputted
        if( column_to_output == 0 )
        {
            word_to_output = line;
            word_to_output_len = len;
        }

        //splitting row into words; finding the specified pattern in words
        match_found = 0;
        word_num = 0; 
        p = line;
        while(!match_found || word_to_output_len==0)
        {
            char* word_start_p;
            size_t word_len;

            //skip spaces before next word
            while( isspace(*p) )
                ++p;

            if( !*p )
                break;  //line end, no more words

            //word starting char found
            ++word_num;
            word_start_p = p++;

            //find word end
            while( *p && !isspace(*p) )
                ++p;

            word_len = p - word_start_p;

            //if we are at the N'th column, store the word to be outputted
            if( column_to_output == word_num )
            {
                word_to_output = word_start_p;
                word_to_output_len = word_len;
            }

            //check if this word matches the pattern
            if( !match_found && word_to_search_len <= word_len )
            {
                if( substring_match )
                    match_found = str_idx(word_start_p, word_len, word_to_search_for, word_to_search_len) >=0;
                else
                    match_found = strncmp(word_start_p, word_to_search_for, word_to_search_len) == 0;
            }
        }

        if(match_found && word_to_output_len > 0)
        {
            printf("%s\n", word_to_output);

            if( first_match_only )
                break;
        }
    }

    fclose(fi); fi = NULL;

    return 0;
}

BTW, goto serverfault.com ilyen kerdesekkel batran.