trevorb98/CS3841
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

stuff

Browse Source
This commit is contained in:
p-w-rs
2022-09-30 15:35:16 -05:00
parent b927d70ba7
commit 0924ea2496
4 changed files with 771 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
05-JurrasicPark/README.md Normal file
View File

@@ -0,0 +1,33 @@
## Introduction
For this lab you will create a program that add matrices and times the addition just as in lab 3, except in this lab you will do so with threads.
## Details
You should determine the number of cores on your computer and write a program such that each thread (including the main thread) does and qual amount of computation.
In other words if I have 4 cores (8 threads) on my computer and an 7x7 matrices (49 values) then each thread should do 49 / 8 (integer division) additions with the main thread picking up the any remainder. Thus, in this case, the main thread does 7 addtions and every other thread 6.
Assume all matrices will require each thread to do at least 1 addition.
## Testing and Debugging
There are [several matrix files](matrices.zip) located provided along with this specification. You can use those to help get your programs working. You are also required to create some of your own and include those in your submission. Don't forget to test large matrices.
## Deliverables
You will need to include all your source files and any other resources you used to complete lab.
A makefile is useful, but optional for this assignment. If you created a makefile, include it in your submission.
All files should be well documented with function comment blocks and inline comments that explain complicated code routines. While no explicit style guidelines are set for programming in this course, code should be documented and readable. Include your name, section, and lab name in a comment block at the top of each file.
NOTE: do ***NOT*** submit any IDE configuration files (.idea, project files, etc.). Only submit your source files.
NOTE: You should ensure that this program compiles without warning (-Wall and -Wextra) prior to submitting.
Prepare a zip file with all submitted files and upload the file to Canvas per your instructor's instructions.
## Grading Criteria (100 Points)
Demonstrate that your lab is working by compiling it, running it, and running any test code in person during lab hours.

58
05-JurrasicPark/main.c Normal file
View File

@@ -0,0 +1,58 @@
// os345p3.c - Jurassic Park 07/27/2020
// ***********************************************************************
// ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER **
// ** **
// ** The code given here is the basis for the CS345 projects. **
// ** It comes "as is" and "unwarranted." As such, when you use part **
// ** or all of the code, it becomes "yours" and you are responsible to **
// ** understand any algorithm or method presented. Likewise, any **
// ** errors or problems become your responsibility to fix. **
// ** **
// ** NOTES: **
// ** -Comments beginning with "// ??" may require some implementation. **
// ** -Tab stops are set at every 3 spaces. **
// ** -The function API's in "OS345.h" should not be altered. **
// ** **
// ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER **
// ***********************************************************************
#include <ctype.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "park.h"
// Jurassic Park
extern int begin;
extern JPARK myPark;
extern pthread_mutex_t parkMutex; // mutex park variable access
extern pthread_mutex_t fillSeat[NUM_CARS]; // (signal) seat ready to fill
extern pthread_mutex_t seatFilled[NUM_CARS]; // (wait) passenger seated
extern pthread_mutex_t rideOver[NUM_CARS]; // (signal) ride over
void *carTask(void *args);
void *driverTask(void *args);
void *visitorTask(void *args);
int main(int argc, char *argv[])
{
begin = 0;
// start park
pthread_t parkTask;
pthread_create(&parkTask, NULL, jurassicTask, NULL);
// wait for park to get initialized...
while (!begin)
{
}
printf("\n\nWelcome to Jurassic Park\n\n");
//?? create car, driver, and visitor tasks here
pthread_join(parkTask, NULL);
return 0;
}

630
05-JurrasicPark/park.c Normal file
View File

@@ -0,0 +1,630 @@
// os45park.c - Jurassic Park 10/24/2013
// ***********************************************************************
// ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER **
// ** **
// ** The code given here is the basis for the CS345 projects. **
// ** It comes "as is" and "unwarranted." As such, when you use part **
// ** or all of the code, it becomes "yours" and you are responsible to **
// ** understand any algorithm or method presented. Likewise, any **
// ** errors or problems become your responsibility to fix. **
// ** **
// ** NOTES: **
// ** -Comments beginning with "// ??" may require some implementation. **
// ** -Tab stops are set at every 3 spaces. **
// ** -The function API's in "OS345.h" should not be altered. **
// ** **
// ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER **
// ***********************************************************************
#include <assert.h>
#include <ctype.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include "park.h"
JPARK myPark;
pthread_mutex_t parkMutex; // mutex park variable access
pthread_mutex_t moveCars;
pthread_mutex_t fillSeat[NUM_CARS]; // (signal) seat ready to fill
pthread_mutex_t seatFilled[NUM_CARS]; // (wait) passenger seated
pthread_mutex_t rideOver[NUM_CARS]; // (signal) ride over
void *jurassicTask(void *args)
{
int i, j, k;
char buf[32];
int c[NUM_CARS];
// initial car locations
for (i = 0; i < NUM_CARS; i++)
{
myPark.cars[i].location = 33 - i;
myPark.cars[i].passengers = 0;
}
// drivers are all asleep
for (i = 0; i < NUM_DRIVERS; i++)
{
myPark.drivers[i] = 0;
}
// initialize other park variables
myPark.numOutsidePark = 0;
// # trying to enter park
myPark.numTicketsAvailable = MAX_TICKETS;
// T=#
myPark.numInPark = 0;
// P=#
myPark.numRidesTaken = 0;
// S=#
myPark.numInTicketLine = 0;
// Ticket line
myPark.numInMuseumLine = 0;
// Museum line
myPark.numInMuseum = 0;
// # in museum
myPark.numInCarLine = 0;
// Ride line
myPark.numInCars = 0;
// # in cars
myPark.numInGiftLine = 0;
// Gift shop line
myPark.numInGiftShop = 0;
// # in gift shop
myPark.numExitedPark = 0;
// # exited park
// create move car signal semaphore
pthread_mutex_init(&moveCars, NULL);
pthread_mutex_lock(&moveCars);
// initialize communication semaphores
for (i = 0; i < NUM_CARS; i++)
{
pthread_mutex_init(&fillSeat[i], NULL);
pthread_mutex_lock(&fillSeat[i]);
pthread_mutex_init(&seatFilled[i], NULL);
pthread_mutex_lock(&seatFilled[i]);
pthread_mutex_init(&rideOver[i], NULL);
pthread_mutex_lock(&rideOver[i]);
}
// start display park task
pthread_t displayTask;
pthread_create(&displayTask, NULL, jurassicDisplayTask, NULL);
// OK, let's get the park going...
pthread_mutex_init(&parkMutex, NULL);
begin = 1;
// start lost visitor task
pthread_t lostTask;
pthread_create(&lostTask, NULL, lostVisitorTask, NULL);
// wait to move cars
do
{
// wait for signal to move cars
ParkDebug("WAIT(moveCars)");
pthread_mutex_lock(&moveCars);
// order car locations
for (i = 0; i < NUM_CARS; i++)
{
c[i] = i;
}
// sort car positions
for (i = 0; i < (NUM_CARS - 1); i++)
{
for (j = i + 1; j < NUM_CARS; j++)
{
if (myPark.cars[c[i]].location < myPark.cars[c[j]].location)
{
k = c[i];
c[i] = c[j];
c[j] = k;
}
}
}
// move each car if possible (or load or unload)
for (i = 0; i < NUM_CARS; i++)
{
// move car (-1=location occupied, 0=moved, 1=no move)
if (makeMove(c[i]))
{
// check if car is loading
if ((myPark.cars[c[i]].location == 33) && (myPark.cars[c[i]].passengers < NUM_SEATS) &&
(myPark.numInCarLine))
{
// need a passenger
sprintf(buf, "SIGNAL(fillSeat[%d])", c[i]);
ParkDebug(buf);
pthread_mutex_unlock(&fillSeat[c[i]]);
// seat open
sprintf(buf, "WAIT(seatFilled[%d])", c[i]);
ParkDebug(buf);
pthread_mutex_unlock(&seatFilled[c[i]]);
// passenger in seat
myPark.cars[c[i]].passengers++;
}
// check if car is unloading
if ((myPark.cars[c[i]].location == 30) && (myPark.cars[c[i]].passengers > 0))
{
// empty each seat until car is empty
myPark.numRidesTaken++;
// if car empty, signal ride over
if (--myPark.cars[c[i]].passengers == 0)
{
sprintf(buf, "SIGNAL(rideOver[%d])", c[i]);
ParkDebug(buf);
pthread_mutex_unlock(&rideOver[c[i]]);
}
}
// sanity check
if ((myPark.cars[0].location == myPark.cars[1].location) ||
(myPark.cars[0].location == myPark.cars[2].location) ||
(myPark.cars[0].location == myPark.cars[3].location) ||
(myPark.cars[1].location == myPark.cars[2].location) ||
(myPark.cars[1].location == myPark.cars[3].location) ||
(myPark.cars[2].location == myPark.cars[3].location))
{
printf("\nProblem:");
for (k = 0; k < NUM_CARS; k++)
printf(" %d", myPark.cars[k].location);
k = getchar();
}
}
}
} while (myPark.numExitedPark < NUM_VISITORS);
// park done
printf("\nJurassic Park is shutting down for the evening!!");
return NULL;
} // end
//***********************************************************************
// Move car in Jurassic Park (if possible)
//
// return -1 if location occupied
// 0 if move ok
// 1 if no move
//
int makeMove(int car)
{
int i, j;
int moved;
switch (j = myPark.cars[car].location)
{
// at cross roads 1
case 7: {
j = (rand() % 2) ? 24 : 8;
break;
}
// at cross roads 2
case 20: {
// take shorter route if no one in line
if (myPark.numInCarLine == 0)
{
j = 28;
}
else
{
j = (rand() % 3) ? 28 : 21;
}
break;
}
// bridge loop
case 23: {
j = 1;
break;
}
// bridge short route
case 27: {
j = 20;
break;
}
// exit car
case 30: {
if (myPark.cars[car].passengers == 0)
{
j++;
}
break;
}
// loading car
case 33: {
// if there is someone in car and noone is in line, proceed
// if ((myPark.cars[car].passengers == NUM_SEATS) ||
// ((myPark.numInCarLine == 0) && myPark.cars[car].passengers))
// if car is full, proceed into park
if (myPark.cars[car].passengers == NUM_SEATS)
{
j = 0;
}
break;
}
// all other moves
default: {
j++;
break;
}
}
// check to see if position is taken
for (i = 0; i < NUM_CARS; i++)
{
if (i != car)
{
if (myPark.cars[i].location == j)
{
return -1;
}
}
}
// return 0 if car moved
moved = (myPark.cars[car].location == j);
// make move
myPark.cars[car].location = j;
return moved;
}
// ***********************************************************************
// ***********************************************************************
// jurassic task
// ***********************************************************************
void *jurassicDisplayTask(void *args)
{
// wait for park to get initialized...
while (!begin)
{
}
printf("Starting jurassicDisplayTask\n");
// display park every second
do
{
JPARK currentPark;
// update every second
sleep(1);
// take snapshot of park
pthread_mutex_lock(&parkMutex);
currentPark = myPark;
pthread_mutex_unlock(&parkMutex);
// draw current park
drawPark(&currentPark);
// signal for cars to move
pthread_mutex_unlock(&moveCars);
} while (myPark.numExitedPark < NUM_VISITORS);
// park done
printf("\nThank you for visiting Jurassic Park!!");
return NULL;
} // end
//***********************************************************************
// Draw Jurassic Park
// 1 2 3 4 5 6 7
// 01234567890123456789012345678901234567890123456789012345678901234567890
// _______________________________________________________ 0
// Entrance / ++++++++++++++++++++++++++++++++++++++++++| 1
// - +o0o-o1o-o2o-o3o-o4o-o5o-o6o +| 2
// ## - /+ / \ +| 3
// / o + o ************ o +| 4
// |******** ##>>33 + 23 *Cntrl Room* 7 +| 5
// |*Ticket* o + o * A=# D1=# * o +| 6
// |*Booth * 32 + | * B=# D2=# * / \ +| 7
// |* T=# * ## o + o * C=# D3=# * o o8o-o9o +| 8
// |* P=## * 31 + 22 * D=# D4=# * 24 \ +| 9
// |* S=# * o + o ************ o o +| 10
// |******** ##<<30 + \ / 10 +| 11
// | o + o21-o20-o27-o26-o25 o +| 12
// | \+ / \ | +| 13
// | +o29-o28 o o +| 14
// | +++++++++++ 19 11 +| 15
// | + o o +| 16
// | ## ## + \ / +| 17
// | ******\ /****\ /******** + o O\ o +| 18
// | * * * + 18 \/|||\___ 12 +| 19
// \ * Gifts * Museum * + o x x o +| 20
// - * # * ## * + \ / +| 21
// ## - * * * + o17-o16-o15-o14-o13 +| 22
// \ ************************ ++++++++++++++++++++++++++++++++| 23
//
char *myTime(char *svtime)
{
time_t cTime; // current time
time(&cTime); // read current time
strcpy(svtime, asctime(localtime(&cTime)));
svtime[strlen(svtime) - 1] = 0; // eliminate nl at end
return svtime;
} // end myTime
#define D1Upper 13
#define D1Left 45
#define D1Lower 18
#define D1Right 53
#define D2Upper 4
#define D2Left 53
#define D2Lower 13
#define D2Right 57
void drawPark(JPARK *park)
{
static int direction1 = D1Left;
static int dy1 = D1Lower;
static int direction2 = D2Left;
static int dy2 = D1Lower - 9;
int i, j;
char svtime[64]; // ascii current time
char driver[] = {'T', 'z', 'A', 'B', 'C', 'D'};
char buf[32];
char pk[25][80];
static int cp[34][3] = {
{2, 29, 0}, {2, 33, 0}, {2, 37, 0}, {2, 41, 0}, // 0-6
{2, 45, 0}, {2, 49, 0}, {2, 53, 0}, {4, 57, 1}, // 7
{8, 59, 0}, {8, 63, 0}, // 8-9
{10, 67, 1}, {14, 67, 1}, {18, 65, 1}, // 10-12
{22, 61, 0}, {22, 57, 0}, {22, 53, 0}, // 13-17
{22, 49, 0}, {22, 45, 0}, {18, 43, 1}, {14, 41, 1}, // 18-19
{12, 37, 0}, {12, 33, 0}, {8, 31, 1}, {4, 31, 1}, // 20-23
{8, 55, 3}, // 24
{12, 49, 0}, {12, 45, 0}, {12, 41, 0}, // 25-27
{14, 33, 0}, {14, 29, 0}, // 28-29
{10, 26, 1}, {8, 26, 1}, {6, 26, 1}, {4, 26, 1}, // 30-33
};
strcpy(&pk[0][0], " ___Jurassic Park_______________________________________");
strcpy(&pk[1][0], " Entrance / ++++++++++++++++++++++++++++++++++++++++++|");
strcpy(&pk[2][0], " - +--------------------------- +|");
strcpy(&pk[3][0], " # - /+ / \\ +|");
strcpy(&pk[4][0], " / | + | ************ | +|");
strcpy(&pk[5][0], " |******** # >>| + | *Cntrl Room* | +|");
strcpy(&pk[6][0], " |*Ticket* | + | * A=# D1=# * | +|");
strcpy(&pk[7][0], " |*Booth * | + | * B=# D2=# * / \\ +|");
strcpy(&pk[8][0], " |* T=# * # | + | * C=# D3=# * / ------- +|");
strcpy(&pk[9][0], " |* P=# * | + | * D=# D4=# * / \\ +|");
strcpy(&pk[10][0], " |* S=# * | + | ************ / | +|");
strcpy(&pk[11][0], " |******** <<| + \\ / | +|");
strcpy(&pk[12][0], " | | + ------------------- | +|");
strcpy(&pk[13][0], " | \\+ / \\ | +|");
strcpy(&pk[14][0], " | +------- | | +|");
strcpy(&pk[15][0], " | +++++++++++ | | +|");
strcpy(&pk[16][0], " | + | | +|");
strcpy(&pk[17][0], " | # # + \\ / +|");
strcpy(&pk[18][0], " | ******\\ /****\\ /******** + | | +|");
strcpy(&pk[19][0], " | * * * + | | +|");
strcpy(&pk[20][0], " \\ * Gifts * Museum * + | | +|");
strcpy(&pk[21][0], " - * * * + \\ / +|");
strcpy(&pk[22][0], " # - * * * + ------------------- +|");
strcpy(&pk[23][0], " \\ ************************ ++++++++++++++++++++++++++++++++|");
strcpy(&pk[24][0], " Exit \\_____________________________________________________________|");
// output time
sprintf(buf, "%s", myTime(svtime));
memcpy(&pk[0][strlen(pk[0]) - strlen(buf)], buf, strlen(buf));
// out number waiting to get into park
sprintf(buf, "%d", park->numOutsidePark);
memcpy(&pk[3][12 - strlen(buf)], buf, strlen(buf));
// T=#, out number of tickets available
sprintf(buf, "%d ", park->numTicketsAvailable);
memcpy(&pk[8][8], buf, strlen(buf));
// P=#, out number in park (not to exceed OSHA requirements)
sprintf(buf, "%d ", park->numInPark);
memcpy(&pk[9][8], buf, strlen(buf));
// S=#, output guests completing ride
sprintf(buf, "%d", park->numRidesTaken);
memcpy(&pk[10][8], buf, strlen(buf));
// out number in ticket line
sprintf(buf, "%d ", park->numInTicketLine);
memcpy(&pk[8][13], buf, strlen(buf));
// out number in gift shop line
sprintf(buf, "%d", park->numInGiftLine);
memcpy(&pk[17][21 - strlen(buf)], buf, strlen(buf));
// out number in museum line
sprintf(buf, "%d", park->numInMuseumLine);
memcpy(&pk[17][28 - strlen(buf)], buf, strlen(buf));
// out number in car line
sprintf(buf, "%d", park->numInCarLine);
memcpy(&pk[5][23 - strlen(buf)], buf, strlen(buf));
// out number in gift shop
sprintf(buf, "%d ", park->numInGiftShop);
memcpy(&pk[21][17], buf, strlen(buf));
// out number in museum
sprintf(buf, "%d ", park->numInMuseum);
memcpy(&pk[21][29], buf, strlen(buf));
// out number exited park
sprintf(buf, "%d", park->numExitedPark);
memcpy(&pk[22][5 - strlen(buf)], buf, strlen(buf));
// cars
for (i = 0; i < NUM_CARS; i++)
{
sprintf(buf, "%d", park->cars[i].passengers);
memcpy(&pk[6 + i][42 - strlen(buf)], buf, strlen(buf));
}
// drivers
for (i = 0; i < NUM_DRIVERS; i++)
{
pk[6 + i][46] = driver[park->drivers[i] + 1];
}
// output cars
for (i = 0; i < NUM_CARS; i++)
{
// draw car
j = park->cars[i].location;
switch (cp[j][2])
{
// horizontal
case 0: {
pk[cp[j][0]][cp[j][1] + 0] = 'o';
pk[cp[j][0]][cp[j][1] + 1] = 'A' + i;
pk[cp[j][0]][cp[j][1] + 2] = 'o';
break;
}
// vertical
case 1: {
pk[cp[j][0] + 0][cp[j][1]] = 'o';
// pk[cp[j][0]+1][cp[j][1]] = 'A'+i;
// if ((park->cars[i].passengers > 0) && (park->cars[i].passengers < NUM_SEATS))
if ((park->cars[i].passengers > 0) && ((j == 30) || (j == 33)))
{
pk[cp[j][0] + 1][cp[j][1]] = '0' + park->cars[i].passengers;
}
else
pk[cp[j][0] + 1][cp[j][1]] = 'A' + i;
pk[cp[j][0] + 2][cp[j][1]] = 'o';
break;
}
case 2: {
pk[cp[j][0] + 0][cp[j][1] + 0] = 'o';
pk[cp[j][0] + 1][cp[j][1] + 1] = 'A' + i;
pk[cp[j][0] + 2][cp[j][1] + 2] = 'o';
break;
}
case 3: {
pk[cp[j][0] + 0][cp[j][1] - 0] = 'o';
pk[cp[j][0] + 1][cp[j][1] - 1] = 'A' + i;
pk[cp[j][0] + 2][cp[j][1] - 2] = 'o';
break;
}
}
}
// move dinosaur #1
dy1 = dy1 + (rand() % 3) - 1;
if (dy1 < D1Upper)
dy1 = D1Upper;
if (dy1 > D1Lower)
dy1 = D1Lower;
if (direction1 > 0)
{
memcpy(&pk[dy1 + 0][direction1 + 4], "... /O", 7);
memcpy(&pk[dy1 + 1][direction1 + 0], "___/|||\\/", 9);
memcpy(&pk[dy1 + 2][direction1 + 3], "x x", 5);
if (++direction1 > D1Right)
direction1 = -direction1;
}
else
{
if ((rand() % 3) == 1)
{
memcpy(&pk[dy1 + 0][-direction1 + 4], "...", 3);
memcpy(&pk[dy1 + 1][-direction1 + 1], "__/|||\\___", 10);
memcpy(&pk[dy1 + 2][-direction1 + 0], "O x x", 8);
}
else
{
memcpy(&pk[dy1 + 0][-direction1 + 0], "O\\ ...", 7);
memcpy(&pk[dy1 + 1][-direction1 + 2], "\\/|||\\___", 9);
memcpy(&pk[dy1 + 2][-direction1 + 3], "x x", 5);
}
if (++direction1 > -D1Left)
direction1 = -direction1;
}
// move dinosaur #2
dy2 = dy2 + (rand() % 3) - 1;
if (dy2 < D2Upper)
dy2 = D2Upper;
if (dy2 > D2Lower)
dy2 = D2Lower;
dy2 = (dy2 + 9) >= dy1 ? dy1 - 9 : dy2;
if (direction2 > 0)
{
memcpy(&pk[dy2 + 0][direction2 + 7], "_", 1);
memcpy(&pk[dy2 + 1][direction2 + 6], "/o\\", 3);
memcpy(&pk[dy2 + 2][direction2 + 4], "</ _<", 5);
memcpy(&pk[dy2 + 3][direction2 + 3], "</ /", 4);
memcpy(&pk[dy2 + 4][direction2 + 2], "</ ==x", 6);
memcpy(&pk[dy2 + 5][direction2 + 3], "/ \\", 4);
memcpy(&pk[dy2 + 6][direction2 + 2], "//)__)", 6);
memcpy(&pk[dy2 + 7][direction2 + 0], "<<< \\_ \\_", 9);
if (++direction2 > D2Right)
direction2 = -direction2;
}
else
{
memcpy(&pk[dy2 + 0][-direction2 + 1], "_", 1);
memcpy(&pk[dy2 + 1][-direction2 + 0], "/o\\", 3);
memcpy(&pk[dy2 + 2][-direction2 + 0], ">_ \\>", 5);
memcpy(&pk[dy2 + 3][-direction2 + 2], "\\ \\>", 4);
memcpy(&pk[dy2 + 4][-direction2 + 1], "x== \\>", 6);
memcpy(&pk[dy2 + 5][-direction2 + 2], "/ \\", 4);
memcpy(&pk[dy2 + 6][-direction2 + 1], "(__(\\\\", 6);
memcpy(&pk[dy2 + 7][-direction2 + 0], "_/ _/ >>>", 9);
if (++direction2 > -D2Left)
direction2 = -direction2;
}
// draw park
system("clear");
printf("\n");
for (i = 0; i < 25; i++)
printf("\n%s", &pk[i][0]);
printf("\n");
// driver in only one place at a time
for (i = 0; i < (NUM_DRIVERS - 1); i++)
{
if (park->drivers[i] != 0)
{
for (j = i + 1; j < NUM_DRIVERS; j++)
{
assert("Driver Error" && (park->drivers[i] != park->drivers[j]));
}
}
}
return;
} // end drawPark
// ***********************************************************************
// ***********************************************************************
// lostVisitor task
// ***********************************************************************
void *lostVisitorTask(void *args)
{
int inPark;
while (myPark.numExitedPark < NUM_VISITORS)
{
// number in park
pthread_mutex_lock(&parkMutex);
inPark = myPark.numInTicketLine + myPark.numInMuseumLine + myPark.numInMuseum + myPark.numInCarLine +
myPark.numInCars + myPark.numInGiftLine + myPark.numInGiftShop;
if (inPark != myPark.numInPark)
{
printf("\nSomeone is lost!!!");
printf("\nThere are %d visitors in the park,", myPark.numInPark);
printf("\nbut I can only find %d of them!\n", inPark);
printf("\n numInPark=%d", myPark.numInPark);
printf("\n inPark=%d", inPark);
printf("\nnumInTicketLine=%d", myPark.numInTicketLine);
printf("\nnumInMuseumLine=%d", myPark.numInMuseumLine);
printf("\n numInMuseum=%d", myPark.numInMuseum);
printf("\n numInCarLine=%d", myPark.numInCarLine);
printf("\n numInCars=%d", myPark.numInCars);
printf("\n numInGiftLine=%d", myPark.numInGiftLine);
printf("\n numInGiftShop=%d", myPark.numInGiftShop);
printf("\n");
assert("Too few in Park!" && (inPark == myPark.numInPark));
}
pthread_mutex_unlock(&parkMutex);
}
return NULL;
} // end lostVisitorTask

50
05-JurrasicPark/park.h Normal file
View File

@@ -0,0 +1,50 @@
#ifndef __park_h__
#define __park_h__
#define NUM_CARS 4
#define NUM_DRIVERS 4
#define NUM_SEATS 3
#define NUM_VISITORS (NUM_SEATS * 15)
#define MAX_IN_PARK 20
#define MAX_TICKETS (NUM_CARS * NUM_SEATS)
#define MAX_IN_MUSEUM 5
#define MAX_IN_GIFTSHOP 2
#define ParkDebug(s) printf("\n%s: %s", "Debug", s);
int begin;
typedef struct car
{
int location; // location of car in park
int passengers; // # of passengers in car
} CAR;
typedef struct jpark
{
int numOutsidePark; // # outside of park
int numInPark; // # in park (P=#)
int numTicketsAvailable; // # left to sell (T=#)
int numRidesTaken; // # of tour rides taken (S=#)
int numExitedPark; // # who have exited the park
int numInTicketLine; // # in ticket line
int numInMuseumLine; // # in museum line
int numInMuseum; // # in museum
int numInCarLine; // # in tour car line
int numInCars; // # in tour cars
int numInGiftLine; // # in gift shop line
int numInGiftShop; // # in gift shop
int drivers[NUM_DRIVERS]; // driver state (-1=T, 0=z, 1=A, 2=B, etc.)
CAR cars[NUM_CARS]; // cars in park
} JPARK;
void *jurassicTask(void *args);
void *jurassicDisplayTask(void *args);
void *lostVisitorTask(void *args);
int makeMove(int car);
void drawPark(JPARK *park);
#endif