abclinuxu.cz AbcLinuxu.cz itbiz.cz ITBiz.cz HDmag.cz HDmag.cz abcprace.cz AbcPráce.cz
AbcLinuxu hledá autory!
Inzerujte na AbcPráce.cz od 950 Kč
Rozšířené hledání
×

dnes 03:33 | Nová verze

Byla vydána nová verze 0.25.0 multimediálního přehrávače mpv (Wikipedie) vycházejícího z přehrávačů MPlayer a mplayer2. Z novinek lze zmínit například podporu DVB-T2. Další části mpv byly přelicencovány z GPLv2 nebo novější na LGPLv2.1 nebo novější (#2033).

Ladislav Hagara | Komentářů: 0
dnes 02:22 | Zajímavý projekt

Na Bundle Stars byla spuštěna akce Dollar Forever Bundle. Za 1 dolar lze získat 24 počítačových her bežících na platformě Steam také v Linuxu.

Ladislav Hagara | Komentářů: 0
včera 23:44 | Zajímavý software

Lychee je jedním z open source softwarů pro tvorbu webových fotoalb. Vyžadováno je PHP 5.5 nebo novější a MySQL. Ukázka na stránkách projektu. Zdrojové kódy jsou k dispozici na GitHubu pod open source licencí MIT [reddit].

Ladislav Hagara | Komentářů: 3
včera 22:22 | Zajímavý software

Společnosti Haivision a Wowza společně oznámily vznik SRT Alliance a otevření protokolu pro streamování videa SRT. Podrobnosti v FAQ. Zdrojové kódy SRT jsou k dispozici na GitHubu pod open source licencí LGPLv2.1.

Ladislav Hagara | Komentářů: 0
včera 12:33 | Humor

Byl vydán remake filmu Ghost in the Shell. Tentokrát v Bashi. Zhlédnout lze online na "ssh ghost@theshell.xyz" [Hacker News].

Ladislav Hagara | Komentářů: 14
23.4. 20:40 | Zajímavý článek

Lukáš Růžička v článku S Hydrogenem za lepší rytmus aneb bubeníkem snadno a rychle na MojeFedora.cz představuje automatického bubeníka s názvem Hydrogen (Wikipedie): Hydrogen je velmi vydařený program, který rozhodně nesmí chybět ve výbavě žádného linuxového muzikanta. Umožňuje nejen vytváření jednoduchých bicích doprovodů, ale také sofistikované programování bicích a perkusí, jehož výsledek se naprosto vyrovná drahým

… více »
Ladislav Hagara | Komentářů: 14
23.4. 13:55 | Zajímavý projekt

UPSat (Twitter) je první open source nanodružice (CubeSat). Jedná se o společný projekt nadace Libre Space Foundation a University of Patras. Repozitáře projektu jsou k dispozici na GitHubu. Pod Libre Space Foundation patří také projekt SatNOGS (zprávička), projekt globální sítě open source pozemních satelitních stanic, vítězný projekt soutěže The Hackaday Prize 2014. UPSat je součástí mise QB50 (Twitter). ID UPSatu je GR02. GPS přijímač na UPSatu je od české společnosti SkyFox Labs. Součástí mise QB50 je i česká nanodružice VZLUSAT-1 s ID CZ02.

Ladislav Hagara | Komentářů: 4
21.4. 15:00 | Komunita

V diskusním listu Thunderbird planning vývojáři poštovního klienta Thunderbird řeší, zda by nebylo možné budoucí Thunderbird postavit nad webovými technologiemi, tj. nad Electronem, stejně jako například Nylas Mail. Gecko, nad kterým je Thunderbird postaven, se má hodně změnit. V plánu je odstranění vlastností, které Firefox už nepotřebuje, ale Thunderbird je na nich závislý [Hacker News, reddit].

Ladislav Hagara | Komentářů: 98
21.4. 10:22 | Bezpečnostní upozornění

Společnost Oracle vydala čtvrtletní bezpečnostní aktualizaci svých softwarových produktů (CPU, Critical Patch Update). Opraveno bylo celkově 299 bezpečnostních chyb. V Oracle Java SE je například opraveno 8 bezpečnostních chyb. Vzdáleně zneužitelných bez autentizace je 7 z nich. V Oracle MySQL je opraveno 39 bezpečnostních chyb. Vzdáleně zneužitelných bez autentizace je 11 z nich.

Ladislav Hagara | Komentářů: 8
21.4. 10:00 | Pozvánky

V úterý 25. dubna proběhne další Prague Containers Meetup. Přijďte se nechat inspirovat jak zlepšit build/delivery pipeline vašich kontejnerových aplikací.

little-drunk-jesus | Komentářů: 2
Chystáte se pořídit CPU AMD Ryzen?
 (4%)
 (35%)
 (0%)
 (7%)
 (44%)
 (9%)
Celkem 286 hlasů
 Komentářů: 32, poslední včera 12:24
    Rozcestník

    Dotaz: Prace se soubory

    24.4.2010 14:29 Rogue | skóre: 4
    Prace se soubory
    Přečteno: 733×
    Dobrý den, potřeboval bych od Vás prosím poradit s následujícím problémem:

    Vytvořil jsem si program, který praceje se semafory a sdílenou pamětí, ve kterém mám funkci, čítající jednotlivé akce. Kritická sekce vypadá následovně:
      //*****KS*****
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count ++;
      fprintf(soubor, "%d\n", sharedStuff->count);
      //*****KS*****
    
    V této Kricické Sekci se provádí inkrementaci čítače akcí procesu (count), a výsledek by měl bý pak zapsán do souboru. Problém je v tom, že když do kritické sekce přistoupí procesA, který například vykoná 2 akce, pak procesB, který například vykoná také 2 akce, tak výstup v souboru by měl být například:
    Cislo akce 1 procesA
    Cislo akce 2 procesA
    Cislo akce 3 procesB
    Cislo akce 4 procesB
    
    A v mém souboru je například:
    Cislo akce 1 procesA
    Cislo akce 1 procesA
    Cislo akce 3 procesB
    Cislo akce 4 procesB
    
    Prosím poraďte jak odstranit tento jev, předem děkuji za vaše odpovědi.


    Řešení dotazu:


    Odpovědi

    Fuky avatar 24.4.2010 15:03 Fuky | skóre: 52 | blog: 4u
    Rozbalit Rozbalit vše Re: Prace se soubory
    Přilož celý kód, na kterém to testuješ.
    24.4.2010 15:11 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    COUNTER je normalni struktura
    Práce se semafory je Ok. 
    Práce s procesy je taky Ok myslím že je zbytečné to sem kopírovat.
    Když je funkce processedEvent zavolána cyklicky nastane problém popsaný víše.
    
    
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff,)
    {
      int retCode = 0;
      void *sharedMemory = (void *) 0;
      // Zpristupneni sdilene pameti programu
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        return -1;
      }
      // Zablokovani semaforu
      retCode = sem_wait(semId);
      if (retCode == -1)
      {
        return -1;
      }
      //*****KS*****
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count ++;
      fprintf(soubor, "%d\n", sharedStuff->count);
      //*****KS*****
      // Odblokovani semaforu
      retCode = sem_post(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Zavreni semaforu
      retCode = sem_close(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Odpojeni sdilene pameti
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        return -1;
      }
      return 0;
    }
    
    Fuky avatar 24.4.2010 16:09 Fuky | skóre: 52 | blog: 4u
    Rozbalit Rozbalit vše Re: Prace se soubory

    Práce se semafory je Ok. Práce s procesy je taky Ok myslím že je zbytečné to sem kopírovat.

    Kdyby to bylo OK, tak ti to funguje. Poskytováním neúplných informací moc rychlému řešení neprospěješ, naopak plno lidí se na to nepodívá, protože nemá čas z tebe tahat informace po kousíčkách.

    Bavíš se tady o proceses, ale používáš semafory určené pro synchronizaci vláken. Jak voláš fci sem_init()? Nezkoumal jsem jak je to nyní, ale dříve Linux podporoval pouze pshared = 0 tj. zamykání vláken v rámci jednoho procesu, ale nepodporoval nenulovou hodnotu pro synchronizaci různých procesů. Takže se pro meziprocesovou synchronizaci používaly semafory převzaté z System V IPC a ostatně odtud pochází i tebou použitá fce shmat(). Příklad:

    static void
    set_semvalue(
        int semid,
        int num)
    {
        union semun sem_union;
    
        sem_union.val = 1;
    
        if (semctl(semid, num, SETVAL, sem_union) == -1) {
            syslog(LOG_ERR, "Failed to initialize semaphore %i\n", semid);
            exit(EXIT_FAILURE);
        }
    }
    
    static void
    del_semvalue(
        int semid,
        int num)
    {
        union semun sem_union;
    
        if (semctl(semid, num, IPC_RMID, sem_union) == -1) {
            syslog(LOG_ERR, "Failed to delete semaphore\n");
        }
    }
    
    void
    lock(
        int semid,
        int num)
    {
        struct sembuf sem_b;
    
        sem_b.sem_num = num;
        sem_b.sem_op = -1;
        sem_b.sem_flg = SEM_UNDO;
    
        if (semop(semid, &sem_b, 1) == -1) {
            syslog(LOG_ERR, "semaphore_p failed\n");
            exit(EXIT_FAILURE);
        }
    }
    
    void
    unlock(
        int semid,
        int num)
    {
        struct sembuf sem_b;
    
        sem_b.sem_num = num;
        sem_b.sem_op = 1;
        sem_b.sem_flg = SEM_UNDO;
    
        if (semop(semid, &sem_b, 1) == -1) {
            syslog(LOG_ERR, "semaphore_v failed\n");
            exit(EXIT_FAILURE);
        }
    }
    
    24.4.2010 16:26 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    Ok tak pro úplnost:
    typedef struct counter
    {
      int count; 
    } COUNTER;
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff)
    {
      int retCode = 0;
      void *sharedMemory = (void *) 0;
      // Zpristupneni sdilene pameti programu
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        return -1;
      }
      // Zablokovani semaforu
      retCode = sem_wait(semId);
      if (retCode == -1)
      {
        return -1;
      }
      //*****KS*****
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count ++;
      fprintf(soubor, "%d"\n", sharedStuff->count;
      //*****KS*****
      // Odblokovani semaforu
      retCode = sem_post(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Zavreni semaforu
      retCode = sem_close(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Odpojeni sdilene pameti
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        return -1;
      }
      return 0;
    }
    
    int main()
    { 
      pid_t pid;
      sem_t *semIdA;
      
      int retCode = 0;
      int shmid = 0;
      int i = 0;
      int stepsNumber = 0;
      void *sharedMemory = (void *) 0;
      struct counter *sharedStuff;
    
      // Prace se souborem
      FILE *fw;
      fw = fopen("soubor.txt", "w");
      if (fw == NULL)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni sdilene pameti;
      shmid = shmget((key_t)jmeno, N *sizeof(int), 0666 | IPC_CREAT);
      if (shmid == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count=0;
      printf("Pocet: %d\n", sharedStuff->count);
      
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni semaforu;
      semIdA = sem_open(SEM_NAMEa, O_CREAT, 0666, 0);
      if (semIdA == SEM_FAILED)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Odemknuti semaforu;
      retCode = sem_post(semIdA);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni podprocesu;
      for (; i<2; i++)
      {
        pid = fork();
        switch (pid)
        {
          case -1:
    	// Uvolneni prostredku;
    	fprintf(stderr, "Failed...\n");
            exit(EXIT_FAILURE);
    	break;
          case 0:
    	while (stepsNumber != 0)
    	{
    	  processedEvent(semIdA, fw, shmid, sharedStuff, i);
    	  stepsNumber--;
    	}
    	// Uzavreni souboru
    	retCode = fclose(fw);
    	if (retCode == EOF)
    	{
    	  fprintf(stderr, "Failed...\n");
    	  exit(EXIT_FAILURE);
    	}
    	exit(EXIT_SUCCESS);
    	break;
          default:
    	children[i] = pid;
    	break;
        }
      } 
      }
      // Zavreni semaforu;
      retCode = sem_close(semIdA);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Uvolneni porstredku semaforu;
      retCode = sem_unlink(SEM_NAMEa);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }  
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Smazani sdilene pameti;
      retCode = shmctl(shmid, IPC_RMID, 0);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      } 
      
      exit(EXIT_SUCCESS);
    }
    
    Fuky avatar 24.4.2010 18:28 Fuky | skóre: 52 | blog: 4u
    Rozbalit Rozbalit vše Re: Prace se soubory

    Nejsem si tím naprosto jistý, ale myslím, že adresu semaforu vytvořeného pomocí sem_open() nelze sdílet mezi více procesy. Podle mě by bylo korektní řešení nejprve provést fork() a teprve poté volat sem_open() na stejný soubor tj. získá se přístup ke stejnému semaforu. A ne získat přístup k semaforu a poté ho využívat ve více procesech.

    Případně můžeš semafor vytvořit pomocí sem_init(p_sem, pshared=1, value=1) a uložit jeho adresu přímo do struktury, kterou sdílíš. Máš ho pak k dispozici rovnou a nemusíš ho předávat jako argument fce. Navíc slouží k zamykání právě této struktury, tak mi přijde výhodné, aby byl její součástí.

    Jinak volat za sem_open() dekrementaci semaforu sem_post() je zbytečné, stačí využít čtvrtý argument value a nastavit hodnotu semaforu rovnou při jeho vytváření.

    POSIX semaphores and fork() -- when any process exits, they all lose, access

    24.4.2010 19:31 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    Díky za odpovědi, udělal jsem pár drobných úprav na základě tvého příspěvku, ale pořád se nevyřešil můj původní problém, který jsem uvedl výše.
    24.4.2010 21:29 Sinuhet | skóre: 31
    Rozbalit Rozbalit vše Re: Prace se soubory
    Nemel byste pockat na dobehnuti forknutych potomku pred tim, nez semafor znicite?
    24.4.2010 21:59 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    Ano rodič na ně samozdřejmě čeká to jsem do toho kodu nenakopíroval. Ale to není až tak důležité zajímá mne především zápis do souboru potřebuji vědět v čem je chyby mám pocit že v ošetření kritické sekce, ale nemám tušení jak to opravit.
    24.4.2010 22:11 Sinuhet | skóre: 31
    Rozbalit Rozbalit vše Re: Prace se soubory

    Mate nejaky zvlastni duvod, proc sem nechcete dat kompletni minimalni zkompilovatelny a spustitelny kod, ktery nefunguje?

    24.4.2010 22:31 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    Ok tak tady je kompletni minimalni zkompilovatelny kod. Potřebuji poradit jak opravit problém uvedený v prvním příspěvku. Děkuji za Vaš čas a vaše napady.
    #define jmeno 1234
    #define SEM_NAMEa "/mysema"
    typedef struct counter
    {
      int count; 
    } COUNTER;
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff);
    int main()
    { 
      pid_t pid;
      pid_t children[3];
      sem_t *semIdA;
      
      int retCode = 0;
      int shmid = 0;
      int i = 0;
      int stepsNumber = 0;
      void *sharedMemory = (void *) 0;
      struct counter *sharedStuff;
    
      // Zpracovani parametru programu;
      stepsNumber = 3;
      if (stepsNumber == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      } 
      // Prace se souborem
      FILE *fw;
      fw = fopen("out.txt", "w");
      if (fw == NULL)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni sdilene pameti;
      shmid = shmget((key_t)jmeno, 3 *sizeof(int), 0666 | IPC_CREAT);
      if (shmid == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count=0;
      printf("Pocet: %d\n", sharedStuff->count);
      
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni semaforu;
      semIdA = sem_open(SEM_NAMEa, O_CREAT, 0666, 0);
      if (semIdA == SEM_FAILED)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni podprocesu;
      for (; i<3; i++)
      {
        pid = fork();
        switch (pid)
        {
          case -1:
    	// Uvolneni prostredku;
    	fprintf(stderr, "Failed...\n");
            exit(EXIT_FAILURE);
    	break;
          case 0:
    	while (stepsNumber != 0)
    	{
    	  processedEvent(semIdA, fw, shmid, sharedStuff);
    	  stepsNumber--;
    	}
    	// Uzavreni souboru
    	retCode = fclose(fw);
    	if (retCode == EOF)
    	{
    	  fprintf(stderr, "Failed...\n");
    	  exit(EXIT_FAILURE);
    	}
    	exit(EXIT_SUCCESS);
    	break;
          default:
    	children[i] = pid;
    	break;
        }
      } 
      // Ukonceni potomknu;
      for (i = 0; i<3; i++)
      {
        retCode = waitpid(children[i], NULL, 0);
        if (retCode < 0)
        {
          retCode = kill(children[i], SIGTERM);
          if (retCode == -1)
          {
    	fprintf(stderr, "Failed...\n");
    	exit(EXIT_FAILURE);
          }
        }
      }
      // Zavreni semaforu;
      retCode = sem_close(semIdA);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Uvolneni porstredku semaforu;
      retCode = sem_unlink(SEM_NAMEa);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      
      printf("Pocet: %d\n", sharedStuff->count);
      
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Smazani sdilene pameti;
      retCode = shmctl(shmid, IPC_RMID, 0);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      } 
      
      exit(EXIT_SUCCESS);
    }
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff)
    {
      int retCode = 0;
      void *sharedMemory = (void *) 0;
      // Zpristupneni sdilene pameti programu
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        return -1;
      }
      // Zablokovani semaforu
      retCode = sem_wait(semId);
      if (retCode == -1)
      {
        return -1;
      }
      //*****KS*****
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count ++;
      fprintf(soubor, "%d\n", sharedStuff->count);
      //*****KS*****
      // Odblokovani semaforu
      retCode = sem_post(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Zavreni semaforu
      retCode = sem_close(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Odpojeni sdilene pameti
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        return -1;
      }
      return 0;
    }
    
    24.4.2010 22:34 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory

    Tady jsou jeste hlavickove soubory

    #include <stdlib.h>
    #include <stdio.h>
    #include <errno.h>
    #include <unistd.h>
    #include <signal.h>
    #include <semaphore.h>
    #include <fcntl.h>

    #include <sys/types.h>
    #include <sys/wait.h>
    #include <sys/shm.h>
    #include <sys/ipc.h>

    24.4.2010 23:07 Sinuhet | skóre: 31
    Rozbalit Rozbalit vše Re: Prace se soubory

    Todlencto mi funguje.

    #include <stdlib.h>
    #include <stdio.h>
    #include <errno.h>
    #include <unistd.h>
    #include <signal.h>
    #include <semaphore.h>
    #include <fcntl.h>
    
    #include <sys/types.h>
    #include <sys/wait.h>
    #include <sys/shm.h>
    #include <sys/ipc.h>
    
    
    #define jmeno 1234
    #define SEM_NAMEa "/mysema"
    typedef struct counter
    {
      int count; 
    } COUNTER;
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff);
    int main()
    { 
      pid_t pid;
      pid_t children[3];
      sem_t *semIdA;
      
      int retCode = 0;
      int shmid = 0;
      int i = 0;
      int stepsNumber = 0;
      void *sharedMemory = (void *) 0;
      struct counter *sharedStuff;
    
      // Zpracovani parametru programu;
      stepsNumber = 3;
      if (stepsNumber == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      } 
      // Prace se souborem
      FILE *fw;
      fw = fopen("out.txt", "w");
      if (fw == NULL)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni sdilene pameti;
      shmid = shmget((key_t)jmeno, 3 *sizeof(int), 0666 | IPC_CREAT);
      if (shmid == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count=0;
      printf("Pocet: %d\n", sharedStuff->count);
      
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni semaforu;
      semIdA = sem_open(SEM_NAMEa, O_CREAT, 0666, 0);
      if (semIdA == SEM_FAILED)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Odemknuti semaforu;
      retCode = sem_post(semIdA);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Vytvoreni podprocesu;
      for (; i<3; i++)
      {
        pid = fork();
        switch (pid)
        {
          case -1:
    	// Uvolneni prostredku;
    	fprintf(stderr, "Failed...\n");
            exit(EXIT_FAILURE);
    	break;
          case 0:
    	while (stepsNumber != 0)
    	{
    	  processedEvent(semIdA, fw, shmid, sharedStuff);
    	  stepsNumber--;
    	}
    	// Uzavreni souboru
    	retCode = fclose(fw);
    	if (retCode == EOF)
    	{
    	  fprintf(stderr, "Failed...\n");
    	  exit(EXIT_FAILURE);
    	}
    	  retCode = sem_close(semIdA);
    	  if (retCode == -1)
    	  {
    	    return -1;
    	  }
    	exit(EXIT_SUCCESS);
    	break;
          default:
    	children[i] = pid;
    	break;
        }
      } 
      // Ukonceni potomknu;
      for (i = 0; i<3; i++)
      {
        retCode = waitpid(children[i], NULL, 0);
        if (retCode < 0)
        {
          retCode = kill(children[i], SIGTERM);
          if (retCode == -1)
          {
    	fprintf(stderr, "Failed...\n");
    	exit(EXIT_FAILURE);
          }
        }
      }
      // Zavreni semaforu;
      retCode = sem_close(semIdA);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Uvolneni porstredku semaforu;
      retCode = sem_unlink(SEM_NAMEa);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Zpristupneni sdilene pameti programu;
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      
      printf("Pocet: %d\n", sharedStuff->count);
      
      // Odpojeni sdilene pameti;
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      }
      // Smazani sdilene pameti;
      retCode = shmctl(shmid, IPC_RMID, 0);
      if (retCode == -1)
      {
        fprintf(stderr, "Failed...\n");
        exit(EXIT_FAILURE);
      } 
      
      exit(EXIT_SUCCESS);
    }
    
    int processedEvent(sem_t *semId, FILE* soubor, int shmid, COUNTER *sharedStuff)
    {
      int retCode = 0;
      void *sharedMemory = (void *) 0;
      // Zpristupneni sdilene pameti programu
      sharedMemory = shmat(shmid, (void *) 0, 0);
      if (sharedMemory == (void *) -1)
      {
        return -1;
      }
      // Zablokovani semaforu
      retCode = sem_wait(semId);
      if (retCode == -1)
      {
        return -1;
      }
      //*****KS*****
      sharedStuff = (struct counter *) sharedMemory;
      sharedStuff->count ++;
      fprintf(soubor, "%d\n", sharedStuff->count);
      //*****KS*****
      // Odblokovani semaforu
      retCode = sem_post(semId);
      if (retCode == -1)
      {
        return -1;
      }
      // Zavreni semaforu
    /*  retCode = sem_close(semId);
      if (retCode == -1)
      {
        return -1;
      }
    */
      // Odpojeni sdilene pameti
      retCode = shmdt(sharedMemory);
      if (retCode == -1)
      {
        return -1;
      }
      return 0;
    }
    24.4.2010 23:50 Rogue | skóre: 4
    Rozbalit Rozbalit vše Re: Prace se soubory
    Díky moc. Přesně tohle jsem potřeboval. Musím více trénovat paralelni myšlení. Ještě jednou díky

    Založit nové vláknoNahoru

    Tiskni Sdílej: Linkuj Jaggni to Vybrali.sme.sk Google Del.icio.us Facebook

    ISSN 1214-1267   www.czech-server.cz
    © 1999-2015 Nitemedia s. r. o. Všechna práva vyhrazena.