Jak szybki jest grep? -> grep vs awk, python, rugby, java, perl, C - przeszukiwanie logów - część 10.



Spróbujmy kolejnej optymalizacji, rezygnuję z funkcji systemu operacyjnego exit(), zostając przy samym fork():
C++ - fork
 //
// Copyright (c) 2016 Rafal Jackiewicz
//
// Indent style: Berkeley
//
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <errno.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <sstream>
#include <sys/times.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <fstream>
#define Dneedle_max 6
#define Dnew_line 10
using namespace std;
const int       maxPar = 3;
const int       maxProcess = 32;
static int      end_main = 0;
int             fd;
int             maxproc = 0;
unsigned long   len_max;
const key_t     shm_id = 8274;
char           *fileinmemory;
char            needle[Dneedle_max];
struct stat     fd_st;
struct process_struct {
    pid_t           pid;
    int             returnCode;
    time_t          timeProcSystem_us;
    time_t          timeProcUser_us;
    time_t          countTimeProcess_start;
    time_t          countTimeProcess_stop;
    char           *shm_start;
    unsigned long   shm_diff;
    unsigned long   shm_len;
    int             shm_return_len;
};
struct tms      bufor;
struct process_struct *process = new process_struct[maxProcess];
void            sygnal(int signo, siginfo_t * sigf, void *b);
int
main(int argc, char *argv[])
{
    pid_t           pid_tmp;
    sigset_t        sig_mask;
    int             returnCode,
                    opt_check;
    int             i;
    struct rusage   timeData;
    struct sigaction sigA;
    long            adressum = 0;
    unsigned long   sizetmp;
    unsigned long   shmComputeDiv;
    char           *copyfim = 0;
    if (argc == 1) {
    cout << "Nie podano parametrow w wywolaniu programu." << endl;
    return 128;
    }
    if (argc > (maxPar + 1)) {
    cout << "Za duzo parametrow, maksymalnie podaj " << maxPar <<
        " parametrow." << endl;
    return 129;
    }
    if (argc < (maxPar + 1)) {
    cout << "Za malo parametrow, podaj " << maxPar << " parametrow." <<
        endl;
    return 129;
    }
    while ((opt_check = getopt(argc, argv, "vh")) != (-1)) {
    switch (opt_check) {
    case 'v':
        cout << "Versja 1.0\n" << endl;
        return 130;
    case 'h':
        cout <<
        "Poprawne wywolanie programu: szukany ciąg 6 znaków, plik, ile procesów."
        << endl;
        cout << "Maksymalnie podaj " << maxPar << " parametrów." <<
        endl;
        return 130;
    }
    }
    fd = open(argv[2], O_RDONLY);
    if (fd == -1) {
    perror("Multifind: open.");
    return 1;
    }
    if (fstat(fd, &fd_st) == -1) {
    perror("Multifind: fstat.");
    return 1;
    }
    if (!S_ISREG(fd_st.st_mode)) {
    fprintf(stderr, "%sMultifind: to nie plik.\n", argv[2]);
    return 1;
    }
    len_max = fd_st.st_size;
    // System V API
    int             smid =
    shmget(shm_id, len_max, IPC_CREAT | SHM_NORESERVE | 0666);
    fileinmemory = (char *) shmat(smid, NULL, 0);
    if (*fileinmemory == -1) {
    perror("Multifind: shmat.");
    return 1;
    }
    int             readerr = read(fd, fileinmemory, len_max);
    if (readerr == -1) {
    fprintf(stderr, "Multifind: read.");
    return 1;
    }
    if (close(fd) == -1) {
    perror("Multifind: close.");
    return 1;
    }
    if (strlen(argv[1]) != Dneedle_max) {
    fprintf(stderr, "%sZla dlugośc needle.\n", argv[1]);
    return 1;
    else {
    strcpy(needle, argv[1]);
    }
    maxproc = atoi(argv[3]);
    if (maxproc > maxProcess) {
    fprintf(stderr, "Multifind: za duzo prosesow.");
    return 1;
    else {
    if (maxproc == 0) {
        fprintf(stderr, "Multifind: podales zero procesow.");
        return 1;
    }
    }
    shmComputeDiv = len_max / maxproc;
    for (i = 0; i < maxproc; ++i) {
    process[i].shm_start = fileinmemory + (shmComputeDiv * (i));
    process[i].shm_len = shmComputeDiv;
    }
    process[maxproc - 1].shm_len =
    (fileinmemory + len_max) - process[maxproc - 1].shm_start;
    printf("@ fileinmemory: %p \n", fileinmemory);
    printf("@      len_max: 0x%lX \n", len_max);
    printf("@          sum: 0x%lX \n",
       (long unsigned) fileinmemory + len_max);
    for (i = 1; i < maxproc; ++i) {
    sizetmp = process[i - 1].shm_len;
    copyfim = process[i - 1].shm_start;
    while ((copyfim[sizetmp] != (char) Dnew_line)) {    // ||
        // sizetmp!=0
        --sizetmp;
    }
    process[i - 1].shm_len = sizetmp;
    process[i].shm_start =
        process[i - 1].shm_start + process[i - 1].shm_len;
    }
    process[maxproc - 1].shm_len =
    (fileinmemory + len_max) - process[maxproc - 1].shm_start;
    printf("\n");
    for (i = 0; i < maxproc; ++i) {
    process[i].shm_diff = process[i].shm_start - fileinmemory;
    }
    adressum = 0;
    for (i = 0; i < maxproc; ++i) {
    printf("%2d: shm_start: %p ", i, process[i].shm_start);
    printf("  shm_len: %lX ", process[i].shm_len);
    printf("  shm_diff: %8lX ", process[i].shm_diff);
    adressum += process[i].shm_len;
    printf("  shm_start+shm_len: %lX \n",
           process[i].shm_len + (long int) process[i].shm_start);
    }
    printf("Addr len_max: %lX \n", len_max);
    printf("    Diff sum: %lX \n", adressum);
    printf("\n");
    sigemptyset(&sig_mask);
    sigfillset(&sig_mask);
    sigA.sa_handler = NULL;
    sigA.sa_sigaction = sygnal;
    sigA.sa_mask = sig_mask;
    sigA.sa_flags = SA_SIGINFO;
    sigA.sa_restorer = NULL;
    if (sigaction(SIGCHLD, &sigA, NULL)) {
    perror("Blad sigaction:");
    exit(33);
    }
    for (int i = 0; i < maxproc; i++) {
    process[i].countTimeProcess_start = times(&bufor);
    process[i].pid = fork();
    switch (process[i].pid) {
    case -1:
        cout << "Nie mozna utworzyc nowego procesu nr: " << i << endl;
        break;
    case 0:{
        // ###############################################3
        const int       needle_max = Dneedle_max;
        unsigned long   child_len_max = process[i].shm_len;
        char           *child_fileinmemory;
        int             needle_max_minusone = needle_max - 1;
        child_fileinmemory = fileinmemory + process[i].shm_diff;
        char           *endfileinmemory =
            child_fileinmemory + child_len_max - needle_max + 1;
        char           *mark = child_fileinmemory;
        char           *copymarkstart,
                       *copymarkstop;
        char           *needle_maxminus =
            needle + needle_max_minusone;
        char           *needle_plus = needle + 1;
        unsigned long   needle_max_minustwo = needle_max - 2;
        unsigned long   copylen_max = child_len_max;
        char           *mark_buff = mark;
        int             count_buff;
        while ((mark = (char *) memchr(mark, *needle, copylen_max))
               && (mark < endfileinmemory)) {
            if (mark[needle_max_minusone] == *needle_maxminus) {
            if (memcmp
                (++mark, needle_plus,
                 needle_max_minustwo) == 0) {
                copymarkstart = mark;
                while (*(--copymarkstart) != (char) Dnew_line);
                copymarkstop = mark + needle_max;
                while (*(++copymarkstop) != (char) Dnew_line);
                mark = copymarkstop;
                count_buff = copymarkstop - copymarkstart;
                memmove(mark_buff, ++copymarkstart,
                    count_buff);
                mark_buff += count_buff;
                copylen_max = endfileinmemory - mark;
                break;
            else {
                --copylen_max;
            }
            else {
            ++mark;
            --copylen_max;
            }
        }
        while ((mark = (char *) memchr(mark, *needle, copylen_max))
               && (mark < endfileinmemory)) {
            if (mark[needle_max_minusone] == *needle_maxminus) {
            if (memcmp
                (++mark, needle_plus,
                 needle_max_minustwo) == 0) {
                copymarkstart = mark;
                while (*(--copymarkstart) != (char) Dnew_line);
                copymarkstop = mark + needle_max;
                while (*(++copymarkstop) != (char) Dnew_line);
                mark = copymarkstop;
                count_buff = copymarkstop - copymarkstart;
                memcpy(mark_buff, ++copymarkstart, count_buff);
                mark_buff += count_buff;
                copylen_max = endfileinmemory - mark;
            else {
                --copylen_max;
            }
            else {
            ++mark;
            --copylen_max;
            }
        }
        int            *tmmp =
            (int *) (child_fileinmemory + child_len_max - 8);
        *tmmp = mark_buff - child_fileinmemory;
        return (44);
        break;
        }
    default:
        break;
    }
    }
    do {
    pause();
    }
    while (end_main < (maxproc - 1));
    // uzywam wait pokazujac zachowanie sie tablicy stanu procesu po jego
    // zakonczeniu
    // te dzialania mozna przeniesc do funkcji obslugujacej sygnal
    // i odpytywac sie tam o stan procesu, ktory wlasnie wyslal sysgnal
    // wait3 == wait4(0,...)
    while ((pid_tmp = wait4(0, &returnCode, 0, &timeData)) != (-1)) {
    for (int i = 0; i < maxproc; i++) {
        if (process[i].pid == pid_tmp) {
        process[i].timeProcSystem_us = timeData.ru_stime.tv_usec;
        process[i].timeProcUser_us = timeData.ru_utime.tv_usec;
        process[i].returnCode = returnCode;
        i = maxproc;
        }
    }
    }
    int            *len_buff;
    fstream         file_out;
    file_out.open("wynik_multifind.txt", ios::out);
    if (file_out.good() == true) {
    for (int i = 0; i < maxproc; ++i) {
        len_buff =
        (int *) (fileinmemory + process[i].shm_diff +
             process[i].shm_len - 8);
        file_out.write(process[i].shm_start, *len_buff);
    }
    file_out.close();
    }
    for (int i = 0; i < maxproc; ++i) {
    cout << "*** Proces: [" << i << "], kod zakonczenia: " <<
        (process[i].returnCode >> 8) << endl;
    cout << "Czas pracy procesu: " << (double) (process[i].
                            countTimeProcess_stop -
                            process[i].
                            countTimeProcess_start)
        / sysconf(_SC_CLK_TCK)
        << "s" << endl;
    cout << "Czas procesora w trybie uzytkownika: "
        << setw(8) << (double) process[i].timeProcUser_us /
        CLOCKS_PER_SEC << "s" << endl;
    cout << "Czas procesora w trybie systemowym: " << setw(9) <<
        (double) process[i].timeProcSystem_us /
        CLOCKS_PER_SEC << "s" << endl << endl;
    }
    int             r = shmdt(fileinmemory);
    if (r == -1) {
    perror("Multifind: shmdt.");
    }
    r = shmctl(smid, IPC_RMID, NULL);
    if (r == -1) {
    perror("Multifind: shmCTL.");
    }
    cout << endl;
    return 0;
}
void
sygnal(int signo, siginfo_t * sigf, void *b)
{
    for (int i = 0; i < maxproc; ++i) {
    if (process[i].pid == sigf->si_pid) {
        process[i].countTimeProcess_stop = times(&bufor);
        i = maxproc;
    }
    }
    end_main += 1;
}


Brak komentarzy:

Prześlij komentarz