/* include consume */ void * consume(void *arg) { int i; for ( ; ; ) { Sem_wait(&shared.nstored); /* wait for at least 1 stored item */ Sem_wait(&shared.mutex); if (shared.nget >= nitems) { Sem_post(&shared.nstored); Sem_post(&shared.mutex); return(NULL); /* all done */ } i = shared.nget % NBUFF; if (shared.buff[i] != shared.ngetval) printf("error: buff[%d] = %d\n", i, shared.buff[i]); shared.nget++; shared.ngetval++; Sem_post(&shared.mutex); Sem_post(&shared.nempty); /* 1 more empty slot */ *((int *) arg) += 1; } }
int main(int argc, char *argv[]) { int i, nloop; sem_t *mutex; if(argc != 2) err_quit("usage: incr1 <#loops>"); nloop = atoi(argv[1]); /*创建并初始化信号量*/ mutex = Sem_open(Px_ipc_name(SEM_NAME), O_CREAT | O_EXCL, FILE_MODE, 1); Sem_unlink(Px_ipc_name(SEM_NAME)); /*把标准输出设置为非缓冲区*/ setbuf(stdout, NULL); if(Fork() == 0){/*child*/ for(i = 0; i < nloop; ++i){ Sem_wait(mutex); printf("child: %d\n", count++); Sem_post(mutex); } exit(0); } for(i = 0; i < nloop; ++i){/*parent*/ Sem_wait(mutex); printf ("parent: %d\n", count++); Sem_post(mutex); } exit(0); }
int main(int argc, char *argv[]) { int fd, i, nloop, zero = 0; int *ptr; sem_t *mutex; if(argc != 3) err_quit("usage: incr2 <pathname> <#loops>"); fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE);/*打开文件用于读写,不存在则创建它*/ Write(fd, &zero, sizeof(int));/*写一个值为0的值保存到文件*/ /*调用mmap把刚打开的文件映射到本进程的内存空间中*/ ptr = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); mutex = Sem_open(SEM_NAME, O_CREAT | O_EXCL, FILE_MODE, 1); Sem_unlink(SEM_NAME); setbuf(stdout, NULL);/*把标准输出设置为非缓冲区*/ if(Fork() == 0){ for(i = 0; i < nloop; ++i){ Sem_wait(mutex); printf ("child:%d\n",(*ptr)++); Sem_post(mutex); } exit(0); } for(i = 0; i < nloop; ++i){ Sem_wait(mutex); printf ("parent:%d\n",(*ptr)++); Sem_post(mutex); } return 0; }
void *consume(void * arg) { int i; for(i=0;;){ Sem_wait(&shared.nstored); Sem_wait(&shared.mutex); Sem_post(&shared.mutex); if(shared.buff[i].n==0) { return NULL; } Write(STDOUT_FILENO, shared.buff[i].data, shared.buff[i].n); if(++i==NBUFF) i=0; Sem_post(&shared.nempty); } }
int main(int argc, char *argv[]) { int fd, i, nloop; struct shared *ptr; if(argc != 3) err_quit("usage: incr3 <pathname> <#loop>"); nloop = atoi(argv[2]); /*映射到内存*/ fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE); Write(fd, &shared, sizeof(struct shared)); ptr = Mmap(NULL, sizeof(struct shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); Sem_init(&ptr->mutex, 1, 1);/*初始化信号量*/ setbuf(stdout, NULL); if(Fork() == 0){ for(i = 0; i < nloop; ++i){ Sem_wait(&ptr->mutex); printf("child:%d\n", ptr->count++); Sem_post(&ptr->mutex); } exit(0); } for(i = 0; i < nloop; ++i){ Sem_wait(&ptr->mutex); printf("parent: %d\n", ptr->count++); Sem_post(&ptr->mutex); } return 0; }
int main(int argc, char **argv) { int fd, index, lastnoverflow, temp; long offset; struct shmstruct *ptr; if (argc != 2) err_quit("usage: server2 <name>"); /* 4create shm, set its size, map it, close descriptor */ shm_unlink(Px_ipc_name(argv[1])); /* OK if this fails */ fd = Shm_open(Px_ipc_name(argv[1]), O_RDWR | O_CREAT | O_EXCL, FILE_MODE); ptr = Mmap(NULL, sizeof(struct shmstruct), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Ftruncate(fd, sizeof(struct shmstruct)); Close(fd); /* 4initialize the array of offsets */ for (index = 0; index < NMESG; index++) ptr->msgoff[index] = index * MESGSIZE; /* 4initialize the semaphores in shared memory */ Sem_init(&ptr->mutex, 1, 1); Sem_init(&ptr->nempty, 1, NMESG); Sem_init(&ptr->nstored, 1, 0); Sem_init(&ptr->noverflowmutex, 1, 1); /* 4this program is the consumer */ index = 0; lastnoverflow = 0; for ( ; ; ) { Sem_wait(&ptr->nstored); Sem_wait(&ptr->mutex); offset = ptr->msgoff[index]; printf("index = %d: %s\n", index, &ptr->msgdata[offset]); if (++index >= NMESG) index = 0; /* circular buffer */ Sem_post(&ptr->mutex); Sem_post(&ptr->nempty); Sem_wait(&ptr->noverflowmutex); temp = ptr->noverflow; /* don't printf while mutex held */ Sem_post(&ptr->noverflowmutex); if (temp != lastnoverflow) { printf("noverflow = %d\n", temp); lastnoverflow = temp; } } exit(0); }
/*生产者*/ void *produce(void *arg) { int i; for(i = 0; i < nitems; ++i){ Sem_wait(shared.mutex);/*测试mutex大于0?mutex--:阻塞 这是一个原子操作*/ Sem_wait(shared.nempty);/*测试nempty大于0?nempty--:阻塞*/ shared.buff[i % NBUFF] = i;/*向数组中放i*/ Sem_post(shared.mutex);/*测试mutex等于0?mutex++:阻塞*/ Sem_post(shared.nstored); } return(NULL); }
void *produce(void *arg) { int i; for (i = 0; i < nitems; i++) { Sem_wait(shared.nempty); // wait for at least 1 empty slot Sem_wait(shared.mutex); shared.buff[i % NBUFF] = i; // store i into circular buffer Sem_post(shared.mutex); Sem_post(shared.nstored); // 1 more stored item } return (NULL); }
void *consume(void *arg) { int i; for(i = 0; i < nitems; ++i){ Sem_wait(shared.nstored); Sem_wait(shared.mutex); if(shared.buff[i % NBUFF] != i) printf ("buff[%d] = %d\n",i, shared.buff[i % NBUFF]); Sem_post(shared.mutex); Sem_post(shared.nempty); } return(NULL); }
void consume(void *arg) { int i; for (i = 0; i < nitems; i++) { Sem_wait(shared.nstored); // wait for at least 1 stored item Sem_wait(shared.mutex); if (shared.buff[i % NBUFF] == i) printf("buff[%d] = %d\n", i, shared.buff[i % NBUFF]); Sem_post(shared.mutex); Sem_post(shared.nempty); // 1 more empty slot } return (NULL); }
int main(int argc, char *argv[]) { int fd,i,nloop,zero = 0; int *ptr; sem_t *mutex; if (argc != 3) { err_quit("usage: incr2 <pathname> <#loops> \n"); return -1; } nloop = atoi(argv[2]); fd = Open(argv[1],O_RDWR | O_CREAT,00666); Write(fd, &zero,sizeof(int)); ptr = (int *)Mmap( NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 ); close(fd); mutex =Sem_open(SEM_NAME,O_CREAT | O_EXCL,00666,1); Sem_unlink(SEM_NAME); setbuf(stdout,NULL); if (Fork() == 0) { for (i=0; i<nloop; i++) { Sem_wait(mutex); printf("child: %d \n",(*ptr)++); Sem_post(mutex); } } for (i=0; i<nloop; i++) { Sem_wait(mutex); printf("parent: %d \n",(*ptr)++); Sem_post(mutex); } return 0; }
int main(int argc, char **argv) { int i, nthreads; pthread_t tid[MAXNTHREADS]; if (argc != 3) err_quit("usage: incr_pxsem1 <#loops> <#threads>"); nloop = atoi(argv[1]); nthreads = min(atoi(argv[2]), MAXNTHREADS); /* 4initialize memory-based semaphore to 0 */ Sem_init(&shared.mutex, 0, 0); /* 4create all the threads */ Set_concurrency(nthreads); for (i = 0; i < nthreads; i++) { Pthread_create(&tid[i], NULL, incr, NULL); } /* 4start the timer and release the semaphore */ Start_time(); Sem_post(&shared.mutex); /* 4wait for all the threads */ for (i = 0; i < nthreads; i++) { Pthread_join(tid[i], NULL); } printf("microseconds: %.0f usec\n", Stop_time()); if (shared.counter != nloop * nthreads) printf("error: counter = %ld\n", shared.counter); exit(0); }
/* * ======== doCmd ======== */ static Int doCmd(Int cmdId, Processor_Handle proc) { Int result; GT_2trace(curTrace, GT_ENTER, "doCmd> Enter (cmdId=%d, proc=0x%x)\n", cmdId, proc); //pthread_mutex_lock(&dcmd.gate); Lock_acquire(dcmd.gate); dcmd.proc = proc; dcmd.cmdId = cmdId; //pthread_cond_signal(&dcmd.cmdPresent); Sem_post(dcmd.cmdPresent); //while (dcmd.reply == NONE) { // pthread_cond_wait(&dcmd.replyPresent, &dcmd.gate); //} Sem_pend(dcmd.replyPresent, Sem_FOREVER); result = dcmd.reply; dcmd.reply = NONE; //pthread_mutex_unlock(&dcmd.gate); Lock_release(dcmd.gate); GT_1trace(curTrace, GT_ENTER, "doCmd> Exit (result=%d)\n", result); return (result); }
int main(int argc, char *argv[]) { int fd, i, nloop; pid_t pid; struct shmstruct *ptr; if(argc != 4) err_quit("usage: client1 <shmname> <semname> <#loop>"); nloop = atoi(argv[3]); fd = Shm_open(Px_ipc_name(argv[1]), O_RDWR, FILE_MODE); ptr = Mmap(NULL, sizeof(struct shmstruct), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); mutex = Sem_open(Px_ipc_name(argv[2]), 0); pid = getpid(); for(i = 0; i < nloop; ++i) { Sem_wait(mutex); printf("pid %ld:%d\n", (long)pid, ptr->count++); Sem_post(mutex); } return 0; }
int main(int argc, char **argv) { int fd, i, nloop; int *ptr; sem_t *mutex; if (argc != 2) { err_quit("usage: incr_dev_zero <#loops>"); } nloop = atoi(argv[1]); /* open /dev/zero, map into memory */ fd = Open("/dev/zero", O_RDWR); ptr = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); /* create, initialize, and unlink semaphore */ mutex = Sem_open(SEM_NAME, O_CREAT | O_EXCL, FILE_MODE, 1); Sem_unlink(SEM_NAME); // stdout is unbuffered setbuf(stdout, NULL); if (Fork() == 0) { // child process for (i = 0;i < nloop; ++i) { Sem_wait(mutex); printf("child:%d\n", (*ptr)++); Sem_post(mutex); sleep(1); } exit(0); } for (i = 0;i < nloop; ++i) { Sem_wait(mutex); printf("parent:%d\n", (*ptr)++); Sem_post(mutex); sleep(1); } exit(0); }
/* include consume */ void * consume(void *arg) { int i; for (i = 0; i < nitems; i++) { Sem_wait(&shared.nstored); /* wait for at least 1 stored item */ Sem_wait(&shared.mutex); if (shared.buff[i % NBUFF] != i) printf("error: buff[%d] = %d\n", i, shared.buff[i % NBUFF]); Sem_post(&shared.mutex); Sem_post(&shared.nempty); /* 1 more empty slot */ } return(NULL); }
static int lprintf(log_t *log, unsigned int level, int err_flg, int t_err_code, const char *fmt, va_list ap) { int fd; time_t now; char date[50]; static char line[LOGLINE_MAX]; static char processnum[10]; int len; int errno_save; static char *levels[10] = { "[(bad)]", "[debug]", "[info]", "[warn]", "[error]", "[emerg]", "[fatal]"}; if (NULL == log) return -1; fd = log->fd; if (!(log->flags&LOG_NODATE)) { now = time(NULL); strcpy(date, ctime(&now)); date[strlen(date) - 6] = ' '; date[strlen(date) - 5] = '\0'; } if (!(log->flags&LOG_NOPID)) sprintf(processnum, "(PID:%ld) ", (long) getpid()); snprintf(line, sizeof(line), "%s%s%s", log->flags&LOG_NODATE ? "" : date, log->flags&LOG_NOLVL ? "" : (level > FATAL ? levels[0] : levels[level]), log->flags&LOG_NOPID ? "" : processnum); len = strlen(line); vsnprintf(line+len, sizeof(line) - len, fmt, ap); len = strlen(line); if (1 == err_flg) { errno_save = errno; snprintf(line+len, sizeof(line) - len, ": %s", strerror(errno_save)); } else if (2 == err_flg) snprintf(line+len, sizeof(line) - len, ": %s", strerror(t_err_code)); if (!(log->flags&LOG_NOLF)) strcat(line, "\n"); Sem_wait(&log->sem); Writen(fd, line, strlen(line)); if (EMERG == level && (log->flags&LOG_STDERR)) fprintf(stderr, "%s\n", line); Sem_post(&log->sem); return len; } /* end lprintf */
/* include prodcons */ void * produce(void *arg) { int i; for (i = 0; i < nitems; i++) { printf("prod: calling sem_wait(nempty)\n"); Sem_wait(shared.nempty); /* wait for at least 1 empty slot */ printf("prod: got sem_wait(nempty)\n"); printf("prod: calling sem_wait(mutex)\n"); Sem_wait(shared.mutex); printf("prod: got sem_wait(mutex), storing %d\n", i); shared.buff[i % NBUFF] = i; /* store i into circular buffer */ Sem_post(shared.mutex); Sem_post(shared.nstored); /* 1 more stored item */ } return(NULL); }
int main(int argc, char **argv) { int fd, i, nloop, nusec; pid_t pid; char mesg[MESGSIZE]; long offset; struct shmstruct *ptr; if (argc != 4) err_quit("usage: client2 <name> <#loops> <#usec>"); nloop = atoi(argv[2]); nusec = atoi(argv[3]); /* 4open and map shared memory that server must create */ fd = Shm_open(Px_ipc_name(argv[1]), O_RDWR, FILE_MODE); ptr = Mmap(NULL, sizeof(struct shmstruct), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); pid = getpid(); for (i = 0; i < nloop; i++) { Sleep_us(nusec); snprintf(mesg, MESGSIZE, "pid %ld: message %d", (long) pid, i); if (sem_trywait(&ptr->nempty) == -1) { if (errno == EAGAIN) { Sem_wait(&ptr->noverflowmutex); ptr->noverflow++; Sem_post(&ptr->noverflowmutex); continue; } else err_sys("sem_trywait error"); } Sem_wait(&ptr->mutex); offset = ptr->msgoff[ptr->nput]; if (++(ptr->nput) >= NMESG) ptr->nput = 0; /* circular buffer */ Sem_post(&ptr->mutex); strcpy(&ptr->msgdata[offset], mesg); Sem_post(&ptr->nstored); } exit(0); }
void * consume(void *arg) { int i; for (i = 0; i < nitems; i++) { printf("cons: calling sem_wait(mutex)\n"); Sem_wait(shared.mutex); printf("cons: got sem_wait(mutex)\n"); printf("cons: calling sem_wait(nstored)\n"); Sem_wait(shared.nstored); /* wait for at least 1 stored item */ printf("cons: got sem_wait(nstored)\n"); printf("cons: fetched %d\n", shared.buff[i % NBUFF]); Sem_post(shared.mutex); Sem_post(shared.nempty); /* 1 more empty slot */ } printf("\n"); return(NULL); }
/* include incr */ void * incr(void *arg) { int i; for (i = 0; i < nloop; i++) { Sem_wait(&shared.mutex); shared.counter++; Sem_post(&shared.mutex); } return(NULL); }
void * consume(void *arg) { int i; for (i = 0; ; ) { Sem_wait(&shared.nstored); /* wait for at least 1 stored item */ Sem_wait(&shared.mutex); /* 4critical region */ Sem_post(&shared.mutex); if (shared.buff[i].n == 0) return(NULL); Write(STDOUT_FILENO, shared.buff[i].data, shared.buff[i].n); if (++i >= NBUFF) i = 0; /* circular buffer */ Sem_post(&shared.nempty); /* 1 more empty slot */ } }
void *produce(void *arg) { int i; for (i = 0; ; ) { Sem_wait(&shared.nempty); Sem_wait(&shared.mutex); Sem_post(&shared.mutex); shared.buff[i].n = Read(fd, shared.buff[i].data, BUFFSIZE); if (shared.buff[i].n == 0) { Sem_post(&shared.nstored); return (NULL); } if (++i >= NBUFF) i = 0; Sem_post(&shared.nstored); } }
/* include produce */ void * produce(void *arg) { for ( ; ; ) { Sem_wait(&shared.nempty); /* wait for at least 1 empty slot */ Sem_wait(&shared.mutex); if (shared.nput >= nitems) { Sem_post(&shared.nempty); Sem_post(&shared.mutex); return(NULL); /* all done */ } shared.buff[shared.nput % NBUFF] = shared.nputval; shared.nput++; shared.nputval++; Sem_post(&shared.mutex); Sem_post(&shared.nstored); /* 1 more stored item */ *((int *) arg) += 1; } }
int main(int argc, char **argv) { int fd, i, nloop; struct shared *ptr; if (argc != 3) err_quit("usage: incr3 <pathname> <#loops>"); nloop = atoi(argv[2]); /* 4open file, initialize to 0, map into memory */ fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE); Write(fd, &shared, sizeof(struct shared)); ptr = Mmap(NULL, sizeof(struct shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); /* 4initialize semaphore that is shared between processes */ Sem_init(&ptr->mutex, 1, 1); setbuf(stdout, NULL); /* stdout is unbuffered */ if (Fork() == 0) { /* child */ for (i = 0; i < nloop; i++) { Sem_wait(&ptr->mutex); printf("child: %d\n", ptr->count++); Sem_post(&ptr->mutex); } exit(0); } /* 4parent */ for (i = 0; i < nloop; i++) { Sem_wait(&ptr->mutex); printf("parent: %d\n", ptr->count++); Sem_post(&ptr->mutex); } exit(0); }
/* include diff */ int main(int argc, char **argv) { int i, nloop; int *ptr; sem_t *mutex; if (argc != 2) err_quit("usage: incr_map_anon <#loops>"); nloop = atoi(argv[1]); /* 4map into memory */ ptr = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0); /* end diff */ /* 4create, initialize, and unlink semaphore */ mutex = Sem_open(Px_ipc_name(SEM_NAME), O_CREAT | O_EXCL, FILE_MODE, 1); Sem_unlink(Px_ipc_name(SEM_NAME)); setbuf(stdout, NULL); /* stdout is unbuffered */ if (Fork() == 0) { /* child */ for (i = 0; i < nloop; i++) { Sem_wait(mutex); printf("child: %d\n", (*ptr)++); Sem_post(mutex); } exit(0); } /* 4parent */ for (i = 0; i < nloop; i++) { Sem_wait(mutex); printf("parent: %d\n", (*ptr)++); Sem_post(mutex); } exit(0); }
/* include prodcons */ void * produce(void *arg) { int i; for (i = 0; ; ) { Sem_wait(&shared.nempty); /* wait for at least 1 empty slot */ Sem_wait(&shared.mutex); /* 4critical region */ Sem_post(&shared.mutex); shared.buff[i].n = Read(fd, shared.buff[i].data, BUFFSIZE); if (shared.buff[i].n == 0) { Sem_post(&shared.nstored); /* 1 more stored item */ return(NULL); } if (++i >= NBUFF) i = 0; /* circular buffer */ Sem_post(&shared.nstored); /* 1 more stored item */ } }
int main(int argc, char **argv) { int fd, i, nloop, zero = 0; int *ptr; sem_t *mutex; if (argc != 3) err_quit("Usage: incr1 <pathname> <#loops>"); nloop = atoi(argv[2]); //open file, initialize to 0, map into memory fd = Open(argv[1], O_RDWR | O_CREAT, FILE_MODE); Write(fd, &zero, sizeof(int)); ptr = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); Close(fd); //create, initialize and unlink semaphore mutex = Sem_open(Px_ipc_name(SEM_NAME), O_CREAT | O_EXCL, FILE_MODE, 1); Sem_unlink(Px_ipc_name(SEM_NAME)); setbuf(stdout, NULL); if (Fork() == 0) { for (i = 0; i < nloop; i++) { Sem_wait(mutex); printf("child: %d\n", (*ptr)++); Sem_post(mutex); } exit(0); } for (i = 0; i < nloop; i++) { Sem_wait(mutex); printf("parent: %d\n", (*ptr)++); Sem_post(mutex); } exit(0); }
int main(int argc, char **argv) { sem_t *sem; int val; if (argc != 2) err_quit("Usage: post <name>"); sem = Sem_open(argv[1], 0); Sem_post(sem); Sem_getvalue(sem, &val); printf("value = %d\n", val); exit(0); }
/* * ======== putReply ======== */ static Void putReply(Int status) { //pthread_mutex_lock(&dcmd.gate); dcmd.reply = status; //pthread_cond_signal(&dcmd.replyPresent); Sem_post(dcmd.replyPresent); /* GT_2trace(curTrace, GT_ENTER, "putReply(0x%x): proc = 0x%lx\n", * status, dcmd.proc); */ //pthread_mutex_unlock(&dcmd.gate); }