TicTacToe
A. First Edition
This is comp444 lab2 and it is concentrated on signal, process synchronization.
Your task with this assignment is to create a multi player tac-tac-toe tournament
(Xs and Os). The assignment will be divided into two parts: (1) creating a twoplayer
competition and (2) creating matches for a group of players and reporting
the results. You should proceed as follows:
Part One: The basic competition (80% of grade)
1. You will write a program that serves as the main tournament process. Its
basic role will be to generate and maintain two player processes. The players
will be instances of a player program that will be separate from the
tournament program. In other words, you will fork and exec the 2 player
processes from the tournament process.
2. The player processes must communicate with one another. Since we haven¡¯t
talked about IPC or threads yet, this communication will occur with signals
and shared files.
3. To accomplish this, the parent process must open a file and then allow the
two processes to read and write to this file. Remember, files are not (by
default) closed across fork and exec calls.
4. The two player programs can be passed a number of command line
arguments (you can add whatever you need). At the very least, they will have
to be told whether they represent the X or O player.
5. The two players will then compete in a game of tic-tac-toe. Before they start,
they must know who they are competing against. In other words, they must
know the process ID of their opponent. This cannot be passed on the
command line during the exec call since this information is not available in the
child process (it is returned to the original parent). The easiest way of doing
this is to have the parent process write the two new process IDs to the shared
file so that the two child processes can read the info when they are run.
6. NOTE!!! Even though the file is shared, you cannot just allow your three
processes (parent and two children) to read/write to it at arbitrary times.
Remember, they are all sharing the same file pointer. Instead, you must use
signals to synchronize access. Specifically, you will use SIGUSR1 and
SIGUSR2. You can do this anyway you like but I would suggest that you use
SIGUSR1 to indicate to a child process that the parent has written something
to the file and SIGUSR2 to indicate that the competitor has just written
something to the file. Note that children should not need to write anything
back to the parent.
7. Once the two children know who their competitor is, the game can begin.
Note that the game is played on a 3 by 3 grid so there are 9 possible
positions. The X player will always go first by choosing a random position on
the board (this is an awful way to start the game but it ensures that all games
won¡¯t be exactly the same). You will use rand and seed functions in the C
library to pick the starting position.
8. From this point onward, the two players will proceed one move at a time,
signaling to one another once they complete their next move. Clearly, each
player will have to keep track of the other¡¯s moves. Each process should
therefore update a local version of the board. The game will terminate either
when one player has won or there is a draw (tie). In the latter case, X is
declared the victor (I don¡¯t want you to have to keep playing until someone
wins because tic-tac-toe has a lot of ties).
9. So how do you decide how to make your next move? You will create at least
two playing ¡°strategies¡±. A strategy is a function that, given an existing board,
returns the next move. Please do not waste your time coming up with
complex strategies (unless you want to). A strategy can be as simple as ¡°find
the next open square from 0 to 8¡±, or ¡°find the next open square from 8 to 0¡±.
When the game starts, each player process will randomly pick one of these
two strategies.
10. You must, of course, check at each step to see if the game has been won.
The check is simple: the game is over if there are three identical symbols in
any row, column, or diagonal (8 possibilities in total). It is also over if all
squares are filled (a draw).
Part Two: The Tournament (20%)
To have an actual tournament, there must be more than two players. Ordinarily,
a tournament would consist of a number of rounds, with the final round producing
a single winner. However, the code required to properly manage this type of
tournament would probably be excessive (it¡¯s harder than it might sound due to
the limited communication facilities). To keep things simple, we will just have a
single round that will produce a group of winners. You will have to extend Part
One as follows:
1. The main tournament program should take one command line parameter ¨C P
= the number of players in the tournament. It must be a multiple of two ¨C an
error should result otherwise.
2. Before starting the competitions, the main program must check the resource
limits for the user. Specifically, you must check that the number of processes
and open files (P/2) will not be exceeded (given the command line argument).
3. The main process will start pairs of player processes, with each pair sharing
an open file. These processes will run concurrently (i.e., at the same time). As
such, a group of P/2 files will be open in every process, although each pair of
players will only share one of these.
4. When a game finishes, the parent process will print the process ID of the
losing process. To do so, it will need to
wait for the appropriate number oflosing processes.
5. For winning processes, you will want each one to print its winning board.
However, if there are multiple processes, we can¡¯t just print them to the
screen at once (the output will get mixed together). Therefore, the command
line arguments for the player program should also include a delay value
D.The winning player should wait
D seconds before printing its winning board.So if there were four matches, you would print the results after 1, 2, 3, and 4
seconds. Note that on a very busy system, it¡¯s possible that some of the
results might still get mixed together¡but we won¡¯t worry about that here.
6. Close files and clean up. You don¡¯t need to
wait for the winning processessince everything will now shut down. (The winning processes will be inherited
by init and will be terminated properly.)
Good Luck!
C.The idea of program| How to generate a random seed? | 2005-02-24 | ||||
| I was originally puzzled a lot when "time()"
always return the same seed for srand(). Then I realized it returns the
number in seconds and my program is so fast that all child process are
generated within one second. So, I cannot use time to generate different
seeds for my srand function. I remember in windows there is something like
get cpu_clock numbers. But I cannot find anything in Linux. Professor, do
you have any suggestion for generating different seeds for child processes
except forcing each child to sleep for a while to generate different
seconds in time? Thank you. ¡¡
|
|||||
| get the system limits | 2005-02-21 |
| I am currently doing lab2 and we have to
check for the resource limit for the opened file and processes. We can also use getrlimit() function but this function gives a static result and not the number of resource left. In order to check if we do not reach the limit, I guess we need something to retrieve the actual number of launched processes (for instance) for the real user id. My question is simple : how can we do that ? |
|
| limits | 2005-02-22 |
| Actually, I just wanted you to check the
static resource limits. I should have made this more clear in the
assignment. I'm assuming that you will be running this process as your
only processes(s), so the use of getrlimit() is all I want. I just wanted
you to get a chance to use this function and see how it worked. (Linux
provides a function called getrusage to get current process stats but I
don't believe it provides a list of currently running processes). Dr Eavis |
|
| about requirement no5 in part2 | 2005-02-19 | ||||
| I don't see complete necessity to pass a
delay value as parameter to allow synchronized displaying of winning
teams. That is to say, the parenet process can know the process ID of
winning team (i.e. the winner writes the results in shared files) and can
choose appropriate timing to send a signal to wake up a temperarily
sleeping winning team(after winning the game, the process is a bit tired
and needs a bit of sleep.) to display his winning board followed with a
waitpid call. This will eliminate possibility of messing up of
multi-winner racing for displaying. So, can I treat no. 5 in part 2 as a suggestion instead of requirement as long as I can display winner results properly? Thank you sir.
¡¡ |
|||||
1. This assignment may not be as easy as it seems to be, at least it is true in my case. I spent a little more than
one day to finish all basic frame coding job and begin wondering why the second assignment is much easier than
the first one. Then the wind turns against me when I spent half days to debug for even one small, stupid bug. And
you don't know how many bugs there are. The problem is simply that signal is hard debugging, forked process is
even harder. There is some extra technique for me to trace child process. Finally I have to choose the primitive
printf method for debugging.
2. The synchronization bug is hard to find! Look at following code:
while (!gameOver)
pause();
This is one typical casual coding when you want the signal handler do some job for you. The professor already
emphasized there is a problem, but I just don't understand it until my program seems to work fine with small number
of processes and fail when large number of processes created. You see the signal can be caught in between two lines.
And you program will pause forever. The correct way is like this:
sigprocmask(&signalset);
while (!gameOver)
sigsuspend(&extraSignalSet);
This simple technique is just one of questions in our midterm. I wrote whatever I read in slides without really
understand it.
3. How many critical stages are there in this little game?
My program has a "bullet-proof" synchronization logic since I tried to generate 2000 child players and it works fine. I also design as
many as eight game strategy for finding next tictactoe position instead of the two suggested by professor even though there is no AI at
all.
The game logic is like this:
1. game start:
a) Every child should send a notify signal, SIGUSR1, to parent when he finishes initialization.
b) Parent creates game with carefulness. That is, it creates one child and wait until receives confirmation before proceeds on.
c) Parent send signal SIGUSR1 only to player X and player X starts game and notify player O by SIGUSR2.
d) Player X and player O will never read shared file at any possible moment because they are sharing the same file offset and if their
reading operation interleaves, there will be a corruption of data they read. The logic is like this: parent creates all children
and records all pid's of all children processes in an array of game info struct. Then parent writes game info like pid of both X
and O into file while all children pause. Parent then notify player X only by sending signal SIGUSR1. Player X reads game info
from shared file and finishes first strike of game. Then player X starts the game by notifying player O. Player O wakes up and
check game-start flag to initialize opponent info by reading shared file and then makes its game move and notifies opponent to
let game continue. Therefore there is no danger of concurrent reading of shared file.
e) Using sigsuspend instead of simple pause.
As professor already points out that there is a big problem by using pause like following:
while (!gameOver)
pause();
There is a danger when signal coming between two lines and our program will pause forever. So, I block the signal SIGUSR2 at
beginning and use sigsuspend().
2. game play:
a) Using sigsuspend instead of simple pause.
As professor already points out that there is a big problem by using pause like following:
while (!gameOver)
pause();
There is a danger when signal coming between two lines and our program will pause forever. So, I block the signal SIGUSR2 at
beginning and use sigsuspend().
b) The game-play handler checks game winning condition first. If there is a winner, this player setup game-over flag and game enters
next mode. Only the loser quit.
3. game over:
a) The winner should pause until parent notification for printing game.
b) Parent waits children and counts number of children who quits. When number of quits reaches number of game which is half of number of
players, it iterates all games by sending signal SIGUSR1 to winner player. Parent waits when the winner finishes printing and
quits.
c) There is no need for winner to re-setup signal handler for signal SIGUSR1 since it checks game-over flag for appropriate actions.
d) The loser cannot quit game by itself because the winner won't know if it is quit or not. So, my logic is that it is winner who sends
out a SIGQUIT signal to loser.
The critical synchronization point:
1. Parent needs to send signal SIGUSR1 ONLY WHEN children finishes initialization, otherwise the default handler for this signal is to
ask child process quit! This is the reason for cautious way of creating each child one by one.
2. Player X must also be sure player O has finished initialization. This is difficult to be done between child processes. But when
parent process creates each child with caution, this condition is already satisfied.
3. When loser quits, parent process cannot know when the winner process is ready for printing. So, it is very important to let SIGUSR1
have a single handler setup at the beginning of game. The game-over flag is used for appropriate action instead re-setup signal
handler. This eliminates a slight window of time when handler has not been setup and signal from parent already comes.
4. Only player X will receives signal SIGUSR1 from parent at game start stage. But when game over, both player has a chance to win and
both might be ready to receive SIGUSR1 for printing game.
The misc points:
1. I define many constants which represent appropriate offset in shared file such as PlayerX_Pos etc.
2. When game is over, the parent sends signal to the winner of each game and waits after the winner finishes printing game board. Then
parent proceeds on next game.
3. In order for better debug issue, I set up a small handler when program exits by using "atexit()" to send SIGQUIT to all children
processes. Otherwise when debugging, I often found dozens of children processes running when I have to kill the parent.
¡¡
D.The major functions
¡¡
E.Further improvement
¡¡
F.File listing
1. myhead.h
2. main.c
3. player.c
4. errHandle.c
5. makefile
¡¡
¡¡
file name: myhead.h
#ifndef MYHEAD_H #define MYHEAD_H #include <sys/resource.h> #include <sys/time.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <dirent.h> #include <unistd.h> #include <string.h> #include <fcntl.h> #include <signal.h> //define three mode and it is purely like // DFA=Deterministic Finite Automaton #define FindNext 0 #define Comparing 1 typedef int bool; #define TRUE 1 #define FALSE 0 //for a particular file NAME, NOT path //const int MaxNameLength=20; #define MaxPathLength 128 #define MaxNameLength 20 #define MaxIntLength 20 #define BuffSize 128 #define EmptyGridNode ' '//the empty tic-tac-toe grid #define PlayerTypeLength 2 #define PlayerPidLength (MaxIntLength+1) #define BoardLength 9 //the tic-tac-toe length #define PlayerX_Pos PlayerTypeLength #define PlayerO_Pos (PlayerTypeLength*2+PlayerPidLength) #define BoardPos ((PlayerTypeLength+PlayerPidLength)*2+1) #define WinnerPos (BoardPos+BoardLength+1) #define WinnerTypeLength 1 //simply the X or O void errHandle(char* msg); #endif
¡¡
file name: main.c
#include "myhead.h"
struct GameInfo
{
pid_t playerX;
pid_t playerO;
int fd;
pid_t winner;
};
struct GameInfo* gameinfo;
//const char* tempFileName="gameXXXXXX";
char path[MaxPathLength];
const char* playerFileName="player.exe";
//const int SleepSeconds=2;
int playerNumber, gameNumber;
int gameOverNumber=0;
bool playerReady=FALSE;
//int gameReadyNumber=0;
//bool gameStart=FALSE;
//bool gameOverFlag=FALSE;
void checkResource(int resourceType, int requireNo);
void createGame(int index);
void createPlayer(int index, char* playType);
void writePid(int index);
//void gameOverCount(int no);
void gameReadyCount(int no);
void initialize(int argc, char* argv[]);
void uninitialize();
void clearGame(int index);
int main(int argc, char* argv[])
{
int statloc;
int index;
pid_t pid;
initialize(argc, argv);
for (index=0; index<gameNumber; index++)
{
createGame(index);
//printf("create game index=%d\n", index);
}
for (index=0; index<gameNumber; index++)
{
if (kill(gameinfo[index].playerX, SIGUSR1)<0)
{
errHandle("kill error when create game\n");
}
//don't send signal to playerO, because playerX will notify him.
}
gameOverNumber=0;
//printf("parent waiting game over\n");
while (gameOverNumber<gameNumber)
{
if (wait(&statloc)<0)
{
errHandle("wait error\n");
}
gameOverNumber++;
}
gameOverNumber=0;
//printf("clear game now\n");
printf("Tournament finished and results are like following:('E' for empty grid)\n");
//sleep(3);
do
{
//printf("waiting game no.%d\n", gameOverNumber);
clearGame(gameOverNumber);
//printf("after clear game");
/*
if (wait(&statloc)<0)
{
errHandle("wait error\n");
}
*/
gameOverNumber++;
//pause();
}
while (gameOverNumber<gameNumber);
return 0;
}
void uninitialize()
{
int i;
for (i=0; i<gameNumber; i++)
{
if (close(gameinfo[i].fd)<0)
{
errHandle("close error when end game\n");
}
}
if (kill(0, SIGQUIT)<0)
{
printf("kill error when unintialize\n");
}
free(gameinfo);
}
void clearGame(int index)
{
char winnerType;
pid_t pid, temp;
if (lseek(gameinfo[index].fd, WinnerPos, SEEK_SET)<0)
{
errHandle("seek error when clear game\n");
}
//printf("try to read fd=%d of index=%d\n", gameinfo[index].fd, index);
if (read(gameinfo[index].fd, &winnerType, 1)!=1)
{
errHandle("read error for winnertype\n");
}
if (winnerType=='X')
{
pid=gameinfo[index].playerX;
printf("In game no.%d, player %d is loser\n", index+1, gameinfo[index].playerO);
}
else
{
if (winnerType=='O')
{
pid=gameinfo[index].playerO;
printf("In game no.%d, player %d is loser\n", index+1, gameinfo[index].playerX);
}
else
{
errHandle("unexpected error of winner type\n");
}
}
//printf("try to kill process %d\n", pid);
//while (1)
{
//printf("calling %d\n", pid);
if (kill(pid, SIGUSR1)<0)
{
errHandle("kill error when end game\n");
}
if ((temp=waitpid(pid, NULL, 0))!=pid)
{
printf("wait error return %d\n", temp);
if (kill(0, SIGUSR1)<0)
{
errHandle("cannot kill all processes\n");
}
errHandle("wait error when clear game\n");
}
else
{
//break;
}
}
}
/*
void gameOverCount(int no)
{
gameOverNumber++;
//gameOverFlag=TRUE;
printf("one game is over and gameoverNumber=%d\n", gameOverNumber);
}
*/
void gameReadyCount(int no)
{
playerReady=TRUE;
//printf("one game ready\n");
//gameReadyNumber++;
}
void initialize(int argc, char* argv[])
{
if (argc!=2)
{
errHandle("usage: <main.exe> <player_number>\n");
}
if (sscanf(argv[1], "%d", &playerNumber)==0)
{
errHandle("usage: <main.exe> <player_number>\n");
}
if (playerNumber%2!=0)
{
errHandle("the player number must be multiple of 2\n");
}
gameNumber=playerNumber/2;
checkResource(RLIMIT_OFILE, gameNumber);
checkResource(RLIMIT_NPROC, playerNumber);
if ((gameinfo=(struct GameInfo*)malloc(gameNumber*sizeof(struct GameInfo)))==NULL)
{
errHandle("malloc error when allocate game info\n");
}
if (getcwd(path, MaxPathLength)==NULL)
{
errHandle("getcwd error\n");
}
strcat(path, "/");
strcat(path, playerFileName);
/*
if (signal(SIGCHLD, gameOverCount)==SIG_ERR)
{
errHandle("signal error for game over\n");
}
*/
if (signal(SIGUSR1, gameReadyCount)==SIG_ERR)
{
errHandle("signal error\n");
}
if (atexit(uninitialize)!=0)
{
errHandle("unable setup uninitialize handler for main\n");
}
}
void createPlayer(int index, char* playerType)
{
pid_t pid;
char fdstr[MaxIntLength];
sprintf(fdstr, "%d", gameinfo[index].fd);
playerReady=FALSE;
if ((pid=fork())==0)
{
if (execl(path, playerFileName, playerType, fdstr, NULL)==-1)
{
errHandle("execl error\n");
}
}
else
{
if (playerType[0]=='X')
{
gameinfo[index].playerX=pid;
}
else
{
gameinfo[index].playerO=pid;
}
}
//here we must wait until child response
while (!playerReady)
{
sleep(SleepSeconds);
}
}
void createGame(int index)
{
int fd, i;
char board[BoardLength];
char tempFile[L_tmpnam+1];
for (i=0; i<L_tmpnam; i++)
{
tempFile[i]='X';
}
tempFile[L_tmpnam]='\0';
if ((fd=mkstemp(tempFile))<0)
{
errHandle("temp file create failed\n");
}
//printf("fd=%d\n", fd);
if (unlink(tempFile)<0)
{
errHandle("unlink error\n");
}
for (i=0; i<BoardLength; i++)
{
board[i]=EmptyGridNode;
}
if (lseek(fd, BoardPos, SEEK_SET)<0)
{
errHandle("lseek error when create game\n");
}
if (write(fd, board, BoardLength)!=BoardLength)
{
errHandle("write error for board\n");
}
gameinfo[index].fd=fd;
createPlayer(index, "X");
createPlayer(index, "O");
writePid(index);
}
void writePid(int index)
{
int i;
char pidstr[PlayerTypeLength+PlayerPidLength+1];
pidstr[0]='X';
pidstr[1]=' ';
sprintf(pidstr+PlayerTypeLength, "%d", gameinfo[index].playerX);
for (i=strlen(pidstr); i<PlayerTypeLength+PlayerPidLength; i++)
{
pidstr[i]='\0';
}
if (lseek(gameinfo[index].fd, 0, SEEK_SET)<0)
{
errHandle("error of lseek\n");
}
//printf("write x of %s\n", pidstr);
if (write(gameinfo[index].fd, pidstr, PlayerTypeLength+PlayerPidLength)!=PlayerTypeLength+PlayerPidLength)
{
errHandle("write error for pid\n");
}
pidstr[0]='O';
pidstr[1]=' ';
sprintf(pidstr+PlayerTypeLength, "%d", gameinfo[index].playerO);
for (i=strlen(pidstr); i<PlayerTypeLength+PlayerPidLength; i++)
{
pidstr[i]='\0';
}
if (lseek(gameinfo[index].fd, PlayerTypeLength+PlayerPidLength, SEEK_SET)<0)
{
errHandle("error of lseek\n");
}
if (write(gameinfo[index].fd, pidstr, PlayerTypeLength+PlayerPidLength)!=PlayerTypeLength+PlayerPidLength)
{
errHandle("write error for pid\n");
}
if (fsync(gameinfo[index].fd)<0)
{
errHandle("fsync error\n");
}
}
void checkResource(int resourceType, int requireNo)
{
struct rlimit resource;
if (getrlimit(resourceType, &resource)!=0)
{
errHandle("get resource error\n");
}
if (requireNo>resource.rlim_max)
{
errHandle("require number exceeds resource limit\n");
}
else
{
if (requireNo>resource.rlim_cur)
{
//debug
errHandle("require number exceeds current resource limit\n");
/*
resource.rlim_cur=requireNo;
if (setrlimit(resourceType, &resource)!=0)
{
errHandle("cannot set resource limit to match required number\n");
}
*/
}
}
}
¡¡
¡¡
file name: player.c
#include "myhead.h"
//const int StrategyCount=2;
#define StrategyCount 8
typedef int (*Strategy)();
int strategy1();
int strategy2();
int strategy3();
int strategy4();
int strategy5();
int strategy6();
int strategy7();
int strategy8();
Strategy strategy[StrategyCount]=
{
strategy1, strategy2, strategy3, strategy4,
strategy5, strategy6, strategy7, strategy8
};
pid_t opponent=0;
int fd;
char playerType;
char winnerPlayer;
sigset_t mask;
char board[BoardLength];
bool gameOver=FALSE;
bool gameStart=FALSE;
bool opponentStart=FALSE;
void playGame();
void tictactoe(int no);
void initialize();
void beginPlay(int no);
void readBoard();
void writeBoard(int index);
void notify();
void endGame();
void printBoard(int no);
//all pause call are in main, except playGame function
int main(int argc, char* argv[])
{
if (argc!=3)
{
errHandle("This program is invoked within main.exe. usage: <player.exe><playerType><filedescriptor>\n");
}
//the early the better. otherwise it will be killed by parent's signal
fd=atoi(argv[2]);
playerType=argv[1][0];
initialize();
//printf("before initialize and fd is %d and playertype=%c\n", fd, playerType);
//every one should notify parent when he is ready
if (kill(getppid(), SIGUSR1)<0)
{
errHandle("kill error when notify parent\n");
}
//printf("before play the board is\n");
//readBoard(0);
//printBoard(0);
pause();
//before start playerO must check if playerX already send signal
//printf("player %c ready play game\n", playerType);
playGame();
//at this stage only winner survives
//printf("game over and waiting for parent\n");
pause();//wait until parent ask you to print
return 0;
}
void gameHandler(int no)
{
if (!gameOver)
{
beginPlay(no);
}
else
{
printBoard(no);
}
}
void printBoard(int no)
{
int i;
printf("I am player %c and my pid=%d\n", playerType, getpid());
for (i=0; i<BoardLength; i++)
{
printf("%c", board[i]);
if (i%3==2)
{
printf("\n");
}
}
printf("\n");
}
int strategy1()
{
int i;
for (i=0; i<BoardLength; i++)
{
if (board[i]==EmptyGridNode)
{
break;
}
}
return i;
}
int strategy2()
{
int i;
for (i=BoardLength-1; i>=0; i--)
{
if (board[i]==EmptyGridNode)
{
break;
}
}
return i;
}
int strategy3()
{
int i,j;
for(i=0; i<3; i++)
{
for (j=0; j<BoardLength; j+=3)
{
if (board[i+j]==EmptyGridNode)
{
return i+j;
}
}
}
}
int strategy4()
{
int i,j;
for(i=1; i<=3; i++)
{
for (j=0; j<BoardLength; j+=3)
{
if (board[BoardLength-i-j]==EmptyGridNode)
{
return BoardLength-i-j;
}
}
}
}
int strategy5()
{
int i,j;
for (i=3; i>0; i--)
{
for (j=0; j<BoardLength; j+=3)
{
if (board[BoardLength-i-j]==EmptyGridNode)
{
return BoardLength-i-j;
}
}
}
}
int strategy6()
{
int i,j;
for (i=2; i>=0; i--)
{
for (j=0; j<BoardLength; j+=3)
{
if (board[i+j]==EmptyGridNode)
{
return i+j;
}
}
}
}
int strategy7()
{
int i,j;
for (i=0; i<BoardLength; i+=3)
{
for (j=0; j<3; j++)
{
if (board[i+j]==EmptyGridNode)
{
return i+j;
}
}
}
}
int strategy8()
{
int i,j;
for (i=0; i<BoardLength; i+=3)
{
for (j=1; j<=3; j++)
{
if (board[BoardLength-i-j]==EmptyGridNode)
{
return BoardLength-i-j;
}
}
}
}
void endGame()
{
//everyone can write winner
if (lseek(fd, WinnerPos, SEEK_SET)<0)
{
errHandle("lseek error when write winner\n");
}
if (write(fd, &winnerPlayer, 1)!=1)
{
errHandle("write error\n");
}
//printf("write to fd=%d of %c is winner\n", fd, winnerPlayer);
if (fsync(fd)<0)
{
errHandle("fsync error\n");
}
}
void tictactoe(int no)
{
int index, id;
if (playerType=='O')
{
//when player O executes this routine the very first time
if (!gameStart)
{
//beginPlay(0);
gameStart=TRUE;
//here nobody will send signal unless you notify others
//here is a dangerous zone, since signal from parent can come any moment
//it has the disable interrupt flavour
//maskSignal(SIGUSR1);
beginPlay(0);
//unmaskSignal(SIGUSR1);
//return;
}
}
readBoard();//must read first
//printf("before my move the board is\n");
//printBoard(0);
if (checkGame())//winner?
{
if (winnerPlayer!=playerType)//I am loser
{
//printf("player %d is loser and quit now\n", getpid());
gameOver=FALSE;//I cannot quit NOW!!!!
notify();//still need to notify!!!!
//exit(0);
}
else
{
//the winner kills loser otherwise it might notify again when winner is pausing for parent
endGame();
if (kill(opponent, SIGQUIT)<0)
{
errHandle("kill error when winner kill loser\n");
}
}
}
else
{
//printf("still tictactoe\n");
//strategy should be a function pointer array
id=rand()%StrategyCount;
index=strategy[id]();
if (index<0)
{
printf("id=%d\n", id);
//printBoard(0);
}
writeBoard(index);
notify();
}
}
void notify()
{
//printf("player %d type=%c notify %d \n", getpid(), playerType, opponent);
if (kill(opponent, SIGUSR2)<0)
{
printf("kill error when %d notify %d", getpid(), opponent);
errHandle("notify error\n");
}
}
bool checkGame()
{
int i;
if (board[0]!=EmptyGridNode)
{
if ((board[0]==board[1]&&board[0]==board[2])||(board[0]==board[3]&&board[0]==board[6]))
{
winnerPlayer=board[0];
gameOver=TRUE;
return TRUE;
}
}
if (board[8]!=EmptyGridNode)
{
if ((board[8]==board[7]&&board[8]==board[6])||(board[8]==board[5]&&board[8]==board[2]))
{
winnerPlayer=board[8];
gameOver=TRUE;
return TRUE;
}
}
if (board[4]!=EmptyGridNode)
{
if ((board[4]==board[1]&&board[4]==board[7])||(board[4]==board[3]&&board[4]==board[5])
||(board[4]==board[0]&&board[4]==board[8])||(board[4]==board[2]&&board[4]==board[6]))
{
winnerPlayer=board[4];
gameOver=TRUE;
return TRUE;
}
}
for (i=0; i<BoardLength; i++)
{
if (board[i]==EmptyGridNode)
{
return FALSE;
}
}
winnerPlayer='X';
gameOver=TRUE;
return TRUE;
}
void playGame()
{
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGUSR2);
if (sigprocmask(SIG_BLOCK, &mask, NULL)<0)
{
errHandle("sigprocmask error\n");
}
sigemptyset(&mask);//don't want to another variable
//printf("begin to play game now\n");
if (playerType=='X')
{
notify();
}
while (!gameOver)
{
sigsuspend(&mask);
}
/*
do
{
//printf("player %d is waiting , playerType=%c\n", getpid(), playerType);
//readBoard(0);
//pause();
//printBoard(0);
}
while (!gameOver);
*/
}
void writeBoard(int index)
{
if (lseek(fd, BoardPos+index, SEEK_SET)<0)
{
printf("the argument is %d\n", BoardPos+index);
errHandle("lseek error when write board\n");
}
if (write(fd, &playerType, 1)!=1)
{
errHandle("write error\n");
}
}
void readBoard()
{
if (lseek(fd, BoardPos, SEEK_SET)<0)
{
errHandle("lseek error when read board\n");
}
if (read(fd, board, BoardLength)!=BoardLength)
{
errHandle("read error when reading board\n");
}
}
//read necessary info, this moment, parent has set up game data
//X player must finish first write
//this handler maybe executed twice by PlayerO, but it doesn't matter since
//there is only reading operations.
//playerO will not receive notice from parent!!!
void beginPlay(int no)
{
char buf[PlayerPidLength+1];
int pos;
int offset;
if (playerType=='X')
{
offset=PlayerO_Pos;
}
else
{
offset=PlayerX_Pos;
}
//printf("fd is %d\n", fd);
if (lseek(fd, offset, SEEK_SET)<0)
{
errHandle("seek error when begin play\n");
}
if (read(fd, buf, PlayerPidLength)!=PlayerPidLength)
{
errHandle("read error\n");
}
//the pid must be written with '\0' padded
opponent=atoi(buf);
//printf("opponent is %d\n", opponent);
//the very first move done by X
if (playerType=='X')
{
//write first
pos=rand()%9;
//printf("pos=%d\n", pos);
writeBoard(pos);
// notify();
}
//printf("game start at beginplay of %c\n", playerType);
//the later the safer!
/*
if (playerType=='O')
{
gameStart=TRUE;
}
*/
}
void initialize()
{
//only playerX needs notice from parent
//both player might be winner, so, still we need to set up handler
if (signal(SIGUSR1, gameHandler)==SIG_ERR)
{
errHandle("signal error\n");
}
//they both need to notify each other by SIGUSR2
if (signal(SIGUSR2, tictactoe)==SIG_ERR)
{
errHandle("signal error\n");
}
srand(getpid());
}
file name: errHandle.c
#include "myhead.h"
void errHandle(char* msg)
{
if (msg!=NULL)
{
perror(msg);
}
else
{
strerror(errno);
}
exit(errno);
}
file name: makefile
all: main.exe player.exe @echo "make complete for main.exe " cp -f *.c ./labbackup/ cp -f *.h ./labbackup/ rm -f XXXX* errHandle.o : errHandle.c myhead.h @echo "compiling errHanle module..." gcc -g -c errHandle.c -o errHandle.o main.exe : main.c errHandle.o myhead.h @echo "compiling main.o..." gcc -g main.c errHandle.o -o main.exe player.exe : player.c myhead.h errHandle.o @echo "compiling player.exe..." gcc -g player.c errHandle.o -o player.exe clear : @echo "clear up...\n" rm *.o *.exe rm -f XXXX*
¡¡
How to run?
1. You need the file name as argument in command line
[qingz_hu@alamanni ~/lab1] ./main.exe 2000
Don't try that unless you are patient enough for waiting five minutes even though I did try that!