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í
×
eParkomat, startup z ČR, postoupil mezi finalisty evropského akcelerátoru ChallengeUp!
Robot na pivo mu otevřel dveře k opravdovému byznysu
Internet věcí: Propojený svět? Už se to blíží...
včera 21:21 | Nová verze Ladislav Hagara | Komentářů: 0
včera 11:44 | Zajímavý projekt

Na Indiegogo byla spuštěna kampaň na podporu herní mini konzole a multimediálního centra RetroEngine Sigma od Doyodo. Předobjednat ji lze již od 49 dolarů. Požadovaná částka 20 000 dolarů byla překonána již 6 krát. Majitelé mini konzole si budou moci zahrát hry pro Atari VCS 2600, Sega Genesis nebo NES. Předinstalováno bude multimediální centrum Kodi.

Ladislav Hagara | Komentářů: 0
včera 00:10 | Nová verze

Byla vydána verze 4.7 redakčního systému WordPress. Kódové označením Vaughan bylo vybráno na počest americké jazzové zpěvačky Sarah "Sassy" Vaughan. Z novinek lze zmínit například novou výchozí šablonu Twenty Seventeen, náhledy pdf souborů nebo WordPress REST API.

Ladislav Hagara | Komentářů: 4
6.12. 12:00 | Zajímavý projekt

Projekt Termbox umožňuje vyzkoušet si linuxové distribuce Ubuntu, Debian, Fedora, CentOS a Arch Linux ve webovém prohlížeči. Řešení je postaveno na projektu HyperContainer. Podrobnosti v často kladených dotazech (FAQ). Zdrojové kódy jsou k dispozici na GitHubu [reddit].

Ladislav Hagara | Komentářů: 26
6.12. 11:00 | Bezpečnostní upozornění

Byly zveřejněny informace o bezpečnostní chybě CVE-2016-8655 v Linuxu zneužitelné k lokální eskalaci práv. Chyba se dostala do linuxového jádra v srpnu 2011. V upstreamu byla opravena minulý týden [Hacker News].

Ladislav Hagara | Komentářů: 2
5.12. 22:00 | Komunita

Přibližně před měsícem bylo oznámeno, že linuxová distribuce SUSE Linux Enterprise Server (SLES) běží nově také Raspberry Pi 3 (dokumentace). Obraz verze 12 SP2 pro Raspberry Pi 3 je ke stažení zdarma. Pro registrované jsou po dobu jednoho roku zdarma také aktualizace. Dnes bylo oznámeno, že pro Raspberry Pi 3 je k dispozici také nové openSUSE Leap 42.2 (zprávička). K dispozici je hned několik obrazů.

Ladislav Hagara | Komentářů: 6
5.12. 06:00 | Zajímavý software

OMG! Ubuntu! představuje emulátor terminálu Hyper (GitHub) postavený na webových technologiích (HTML, CSS a JavaScript). V diskusi k článku je zmíněn podobný emulátor terminálu Black Screen. Hyper i Black Screen používají framework Electron, stejně jako editor Atom nebo vývojové prostředí Visual Studio Code.

Ladislav Hagara | Komentářů: 50
5.12. 06:00 | Zajímavý článek

I letos vychází řada ajťáckých adventních kalendářů. QEMU Advent Calendar 2016 přináší každý den nový obraz disku pro QEMU. Programátoři se mohou potrápit při řešení úloh z kalendáře Advent of Code 2016. Kalendáře Perl Advent Calendar 2016 a Perl 6 Advent Calendar přinášejí každý den zajímavé informace o programovacím jazyce Perl. Stranou nezůstává ani programovací jazyk Go.

Ladislav Hagara | Komentářů: 10
3.12. 16:24 | Nová verze

Byla vydána Mageia 5.1. Jedná se o první opravné vydání verze 5, jež vyšla v červnu loňského roku (zprávička). Uživatelům verze 5 nepřináší opravné vydání nic nového, samozřejmě pokud pravidelně aktualizují. Vydání obsahuje všechny aktualizace za posledního téměř půldruhého roku. Mageia 5.1 obsahuje LibreOffice 4.4.7, Linux 4.4.32, KDE4 4.14.5 nebo GNOME 3.14.3.

Ladislav Hagara | Komentářů: 17
3.12. 13:42 | Pozvánky

V Praze probíhá konference Internet a Technologie 16.2, volné pokračování jarní konference sdružení CZ.NIC. Konferenci lze sledovat online na YouTube. K dispozici je také archiv předchozích konferencí.

Ladislav Hagara | Komentářů: 0
Kolik máte dat ve svém domovském adresáři na svém primárním osobním počítači?
 (32%)
 (24%)
 (29%)
 (7%)
 (5%)
 (3%)
Celkem 789 hlasů
 Komentářů: 50, poslední 29.11. 15:50
Rozcestník
Reklama

Dotaz: Prace se soubory

24.4.2010 14:29 Rogue | skóre: 4
Prace se soubory
Přečteno: 729×
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.