VST 3 je nově pod licencí MIT. S verzí 3.8.0 proběhlo přelicencování zdrojových kódů z licencí "Proprietary Steinberg VST3 License" a "General Public License (GPL) Version 3". VST (Virtual Studio Technology, Wikipedie) je softwarové rozhraní pro komunikaci mezi hostitelským programem a zásuvnými moduly (pluginy), kde tyto moduly slouží ke generování a úpravě digitálního audio signálu.
Open source 3D herní a simulační engine Open 3D Engine (O3DE) byl vydán v nové verzi 25.10. Podrobný přehled novinek v poznámkách k vydání.
V Londýně probíhá dvoudenní Ubuntu Summit 25.10. Na programu je řada zajímavých přednášek. Zhlédnout je lze také na YouTube (23. 10. a 24. 10.).
Gemini CLI umožňuje používání AI Gemini přímo v terminálu. Vydána byla verze 0.10.0.
Konference OpenAlt 2025 proběhne již příští víkend 1. a 2. listopadu v Brně. Nabídne přibližně 80 přednášek a workshopů rozdělených do 7 tematických tracků. Program se může ještě mírně měnit až do samotné konference, a to s ohledem na opožděné úpravy abstraktů i případné podzimní virózy. Díky partnerům je vstup na konferenci zdarma. Registrace není nutná. Vyplnění formuláře však pomůže s lepším plánováním dalších ročníků konference.
Samsung představil headset Galaxy XR se 4K Micro-OLED displeji, procesorem Snapdragon XR2+ Gen 2, 16 GB RAM, 256 GB úložištěm, operačním systémem Android XR a Gemini AI.
Před konferencí Next.js Conf 2025 bylo oznámeno vydání nové verze 16 open source frameworku Next.js (Wikipedie) pro psaní webových aplikací v Reactu. Přehled novinek v příspěvku na blogu.
Sovereign Tech Fund oznámil finanční podporu následujících open source projektů: Scala, SDCC, Let's Encrypt, Servo, chatmail, Drupal, Fedify, openprinting, PHP, Apache Arrow, OpenSSL, R Project, Open Web Docs, conda, systemd a phpseclib.
Bylo vydáno OpenBSD 7.8. S předběžnou podporou Raspberry Pi 5. Opět bez písničky.
Valkey (Wikipedie) byl vydán v nové major verzi 9.0. Valkey je fork Redisu.
//*****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 procesBA v mém souboru je například:
Cislo akce 1 procesA Cislo akce 1 procesA Cislo akce 3 procesB Cislo akce 4 procesBProsím poraďte jak odstranit tento jev, předem děkuji za vaše odpovědi.
Řešení dotazu:
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;
}
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);
}
}
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);
}
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
Mate nejaky zvlastni duvod, proc sem nechcete dat kompletni minimalni zkompilovatelny a spustitelny kod, ktery nefunguje?
#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;
}
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>
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;
}
Tiskni
Sdílej: