Exemplo n.º 1
0
int main(void)
{
	int freie_ressourcen;

	/* Anlegen des Semaphors */
	sem_anfordid = sem_create(SEM_READKEY);
	

	/* Setzen des Sempahors auf 1 */
	sem_set(sem_anfordid, 1);


	/* Beginn Serverschleife */
	while(1) {
		
		/* Abfragen wieviel Ressourcen frei sind, falls 0 Schleife verlassen */
		freie_ressourcen = sem_get(sem_anfordid);
		if (freie_ressourcen == 0)
			break;
		
		/* eine Sekunde warten */
		sleep(1);
		
	/* Ende Serverschleife */
	}
	
	/* Semaphor entfernen */
	sem_rm(sem_anfordid);

	printf("Server terminiert.\n");
	exit(0);
}
Exemplo n.º 2
0
void
sem_close(int id)
{
	register int	semval;

	/*
	 * The following semop() first gets a lock on the semaphore,
	 * then increments [1] - the process counter.
	 */

	if (semop(id, &op_close[0], 3) < 0)
		err_sys("can't semop");

	/*
	 * Now that we have a lock, read the value of the process
	 * counter to see if this is the last reference to the
	 * semaphore.
	 * There is a race condition here - see the comments in
	 * sem_create().
	 */

	if ((semval = semctl(id, 1, GETVAL, 0)) < 0)
		err_sys("can't GETVAL");

	if (semval > BIGCOUNT)
		err_dump("sem[1] > BIGCOUNT");
	else if (semval == BIGCOUNT)
		sem_rm(id);
	else
		if (semop(id, &op_unlock[0], 1) < 0)
			err_sys("can't unlock");	/* unlock */
}
Exemplo n.º 3
0
void sem_close(int id)
{
    register int semval;

    if (semop(id, &op_close[0], 3) < 0) perror("can't semop");

    if ( (semval = semctl(id, 1, GETVAL, 0)) < 0) perror("can't GETVAL");
    if (semval > BIGCOUNT) perror("sem[1] > BIGCOUNT");
    else if (semval == BIGCOUNT) sem_rm(id);
    else
        if (semop(id, &op_unlock[0], 1) < 0) perror("can't unlock"); /* unlock */
}
Exemplo n.º 4
0
int main()
{
	int bufferFilledSpaces, bufferEmptySpaces, semM, semN;
	char *buffer;
	int temp;
	int shmid;
	char c1, c2;
	int input = 0;
	int counter;

	char *arg[1] = {0};
	int N;

	// Create duplicate process and give it code from ProcN

	N = fork();

	if (N == 0) // process is a child
	{
		execv("ProcN", arg);
	}

	// Create semaphore bufferFilledSpaces

	bufferFilledSpaces = sem_create(155555, 0);
	if (bufferFilledSpaces < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore bufferEmptySpaces

	bufferEmptySpaces = sem_create(255555, 1);
	if (bufferEmptySpaces < 0)
	{
		Error(1); // Error has occurred
	}

	// Creates synchronization semaphores
	semM = sem_create(355555, 0);
	if (semM < 0)
	{
		Error(1); // Error has occurred
	}

	// Creates synchronization semaphores
	semN = sem_create(455555, 0);
	if (semN < 0)
	{
		Error(1); // Error has occurred
	}

	// Opens shared memory between two processes

	shmid = shm_get(123123, (void*) &buffer, 90);

	// Synchronization with Process N

	temp = sem_signal(semN);
	temp = sem_wait(semM);

	// Part 1 - Fill in initial values

	c1 = 'a';
	c2 = '0';
	counter = 1;

	while (counter <= 260)
	{
		temp = sem_wait(bufferEmptySpaces);

		buffer[input] = c1;
		buffer[input+1] = c2;
		buffer[input+2] = c1;

//Debug
//printf("# %c%c%c #", c1, c2, c1);

		if ((counter % 26) == 0) // Increment number if needed
		{
			c2++;
			c1 = 'a';
		}

		else // Otherwise, move to next letter in alphabet
		{
			c1++;
		}

		counter++;

		temp = sem_signal(bufferFilledSpaces);
	}

	// Part 2 - Fill in initial values

	c1 = 'A';
	c2 = '0';
	counter = 1;

	while (counter <= 260)
	{
		temp = sem_wait(bufferEmptySpaces);

		buffer[input] = c1;
		buffer[input+1] = c2;
		buffer[input+2] = c1;

//Debug
//printf("# %c%c%c #", c1, c2, c1);

		if ((counter % 26) == 0) // Increment number if needed
		{
			c2++;
			c1 = 'A';
		}

		else // Otherwise, move to next letter in alphabet
		{
			c1++;
		}

		counter++;

		temp = sem_signal(bufferFilledSpaces);
	}

	// Synchronization with Process N

	temp = sem_signal(semN);
	temp = sem_wait(semM);

	// Remove semaphores
	
	temp = sem_rm(bufferEmptySpaces);
	temp = sem_rm(bufferFilledSpaces);
	temp = sem_rm(semM);
	temp = sem_rm(semN);

	// Remove shared memory

	temp = shm_rm(shmid);

	printf("\n");
	
	return 1;
}
Exemplo n.º 5
0
int main()
{
	int *BufferA;
	int *BufferB;
	char c1, c2, c3;
	int bufAFilled, bufAEmpty, bufBFilled, bufBEmpty;
	int semX, semY, semZ, CSX, CSY, CSZ;
	int pX, pY;
	char *arg[1] = {0};
	int shmid1, shmid2;
	int temp, loop_finished, counter, input;

	// Create semaphore bufAFilled

	bufAFilled = sem_create(500001, 0);
	if (bufAFilled < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore bufAEmpty

	bufAEmpty = sem_create(500002, 11);
	if (bufAEmpty < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore bufBFilled

	bufBFilled = sem_create(500003, 0);
	if (bufBFilled < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore bufBEmpty

	bufBEmpty = sem_create(500004, 23);
	if (bufBEmpty < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore semX

	semX = sem_create(500005, 0);
	if (semX < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore semY

	semY = sem_create(500006, 0);
	if (semY < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore semZ

	semZ = sem_create(500007, 0);
	if (semZ < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore CSX

	CSX = sem_create(500008, 0);
	if (CSX < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore CSY

	CSY = sem_create(500009, 0);
	if (CSY < 0)
	{
		Error(1); // Error has occurred
	}

	// Create semaphore CSZ

	CSZ = sem_create(500010, 0);
	if (CSZ < 0)
	{
		Error(1); // Error has occurred
	}

	// Opens shared memory between two processes

	shmid1 = shm_get(900001, (void*) &BufferA, 22);

	// Opens shared memory between two processes

	shmid2 = shm_get(900002, (void*) &BufferB, 69);


	// Create duplicate processes and give them code for processes X and Y

	pX = fork();

	if (pX == 0) // process is a child
	{
		execv("ProcX", arg);
	}

	pY = fork();

	if (pY == 0) // process is a child
	{
		execv("ProcY", arg);
	}


	// Synchronize with ProcX and ProcY

	temp = sem_signal(semX);
	temp = sem_signal(semY);
	temp = sem_wait(semZ);
	temp = sem_wait(semZ);


	// Take out items from buffers when elements exist

	counter = 1;
	input = 0;

	while (counter <= 260)
	{
		// Wait until both of the buffers have been filled

		temp = sem_wait(CSZ);
		temp = sem_wait(CSZ);

		// Remove one item from BufferA when one exists

		temp = sem_wait(bufAFilled);

		c1 = BufferA[input*2];
		c2 = BufferA[input*2+1];

		printf("+ %c%c +", c1, c2);

		temp = sem_signal(bufAEmpty);

		// Remove one item from BufferB when one exists

		temp = sem_wait(bufBFilled);

		c1 = BufferB[input*3];
		c2 = BufferB[input*3+1];
		c3 = BufferB[input*3+2];

		printf("+ %c%c%c +", c1, c2, c3);

		temp = sem_signal(bufBEmpty);

		if ((counter % 160) == 0) // Sleep after taking every 160 items
		{
//			printf("-!Sleeping 3 seconds!-");
//			sleep(3);
		}

		counter++;

		// Signal the commencement of the filling both the buffers

		temp = sem_signal(CSX);
		temp = sem_signal(CSY);
	}

	// Synchronize with ProcX and ProcY

	temp = sem_signal(semX);
	temp = sem_signal(semY);
	temp = sem_wait(semZ);
	temp = sem_wait(semZ);

//	sleep(7);

	printf("\n");

	// Remove semaphores
	
	temp = sem_rm(bufAEmpty);
	temp = sem_rm(bufAFilled);
	temp = sem_rm(bufBEmpty);
	temp = sem_rm(bufBFilled);
	temp = sem_rm(semX);
	temp = sem_rm(semY);
	temp = sem_rm(semZ);
	temp = sem_rm(CSX);
	temp = sem_rm(CSY);
	temp = sem_rm(CSZ);

	// Remove shared memory

	temp = shm_rm(shmid1);
	temp = shm_rm(shmid2);

	printf("\nProcZ: Exiting...\n");

	return 1;
}