static void initiateMating() { if (mateLock==NULL) { mateLock = lock_create("mateLock"); if (mateLock == NULL) { panic("mateLock: lock_create failed\n"); } } if (male_go==NULL) { male_go = cv_create("male_go"); if (male_go == NULL) { panic("male_go: cv_create failed\n"); } } if (female_go==NULL) { female_go = cv_create("female_go"); if (female_go == NULL) { panic("female_go: cv_create failed\n"); } } if (matchmaker_go==NULL) { matchmaker_go = cv_create("matchmaker_go"); if (matchmaker_go == NULL) { panic("matchmaker_go: cv_create failed\n"); } } if (doneSem==NULL) { doneSem = sem_create("doneSem", 0); if (doneSem == NULL) { panic("doneSem: sem_create failed\n"); } } }
void whalemating_init() { maleCv = cv_create("male"); femaleCv = cv_create("female"); matchMakerCv = cv_create("matchMaker"); whaleLock = lock_create("whaleLock"); return; }
static void inititems(void) { if (BrSem==NULL) { BrSem = sem_create("BrSem", 3); if (BrSem == NULL) { panic("BrSem: sem_create failed\n"); } } if (doneSem==NULL) { doneSem = sem_create("doneSem", 0); if (doneSem == NULL) { panic("synchtest: sem_create failed\n"); } } if (BrLock==NULL) { BrLock = lock_create("BrLock"); if (BrLock == NULL) { panic("BrLock: lock_create failed\n"); } } if (boyCV==NULL) { boyCV = cv_create("boyCV"); if (boyCV == NULL) { panic("boyCV: cv_create failed\n"); } } if (girlCV==NULL) { girlCV = cv_create("girlCV"); if (girlCV == NULL) { panic("girlCV: cv_create failed\n"); } } }
void whalemating_init() { wm_lock = lock_create("whales"); wm_mcv = cv_create("males"); wm_fcv = cv_create("females"); wm_mmcv = cv_create("matchmakers"); }
/* * The simulation driver will call this function once before starting * the simulation * * You can use it to initialize synchronization and other variables. * */ void intersection_sync_init(void) { /* replace this default implementation with your own implementation */ // intersectionSem = sem_create("intersectionSem",1); intersection_lock = lock_create("intersectionlock"); next_lights = q_create(4); // // Direction x = north; // n = south; // Direction *x_p = &n; // // Direction x1 = south; // Direction *x1_p = &n; // // Direction x2 = east; // Direction *x2_p = &n; north_dir = north; south_dir = south; east_dir = east; west_dir = west; num_vehicles_waiting_north = 0; num_vehicles_waiting_south = 0; num_vehicles_waiting_east = 0; num_vehicles_waiting_west = 0; num_vehicles_waiting_b = 0; // Direction *x3_p = &n; // q_addtail(next_lights, x_p); // q_addtail(next_lights, x1_p); // q_addtail(next_lights, x2_p); // q_addtail(next_lights, x3_p); // current_light = q_peek(next_lights); // n = north; // current_light = &n; //*num_vehicles_waiting = 0; is_waiting = false; cv_south_go = cv_create("cv_south"); cv_north_go = cv_create("cv_north"); cv_east_go = cv_create("cv_east"); cv_west_go = cv_create("cv_west"); // if (intersectionSem == NULL) { // panic("could not create intersection semaphore"); // } if (intersection_lock == NULL) { panic("could not create intersection lock"); } if (cv_south_go == NULL || cv_north_go == NULL || cv_east_go == NULL || cv_west_go == NULL) { panic("could not create intersection cv lock"); } return; }
void pid_bootstrap(){ int s = splhigh(); //kprintf("bootstraping pid\n"); int i; errsuperflag = 0; curthread->ppid = kernelpid; pid_array[kernelpid] = curthread; exit_array[kernelpid] = 0; interest_array[kernelpid]=0; parent_array[kernelpid]=kernelpid; for(i=1;i<MAX_PIDS;i++){ pid_array[i] = NULL; exit_array[i] = 1234; interest_array[i]=-1; parent_array[i]=-1; wait_array[i]=cv_create("cv"); wait_lock[i]=lock_create("lock"); } splx(s); return; }
void test_cv_broadcast() { long i; int result; unintr_printf("starting cv broadcast test\n"); unintr_printf("threads should print out in reverse order\n"); testcv_broadcast = cv_create(); testlock = lock_create(); done = 0; testval1 = NTHREADS - 1; for (i = 0; i < NTHREADS; i++) { result = thread_create((void (*)(void *)) test_cv_broadcast_thread, (void *)i); assert(thread_ret_ok(result)); } while (__sync_fetch_and_add(&done, 0) < NTHREADS) { /* this requires thread_yield to be working correctly */ thread_yield(THREAD_ANY); } assert(interrupts_enabled()); cv_destroy(testcv_broadcast); assert(interrupts_enabled()); unintr_printf("cv broadcast test done\n"); }
/* * The CatMouse simulation will call this function once before any cat or * mouse tries to each. * * You can use it to initialize synchronization and other variables. * * parameters: the number of bowls */ void catmouse_sync_init(int bowls) { /* replace this default implementation with your own implementation of catmouse_sync_init */ /* This is the default implementation (void)bowls; // keep the compiler from complaining about unused parameters globalCatMouseSem = sem_create("globalCatMouseSem",1); if (globalCatMouseSem == NULL) { panic("could not create global CatMouse synchronization semaphore"); } return; */ myLock = lock_create("myLock"); KASSERT(myLock != NULL); lock_acquire(myLock); ava_bowl = kmalloc(bowls * sizeof(bool)); KASSERT(ava_bowl != NULL); for(int i = 0; i < bowls; i++) { ava_bowl[i] = true; } num_cat_eating = 0; num_mouse_eating = 0; // wchan_cat = cv_create("cat"); // wchan_mouse = cv_create("mouse"); wchan_all = cv_create("all"); lock_release(myLock); return; }
/* * Create a pidinfo structure for the specified pid. */ static struct pidinfo * pidinfo_create(pid_t pid, pid_t ppid) { struct pidinfo *pi; KASSERT(pid != INVALID_PID); pi = kmalloc(sizeof(struct pidinfo)); if (pi==NULL) { return NULL; } pi->pi_cv = cv_create("pidinfo cv"); if (pi->pi_cv == NULL) { kfree(pi); return NULL; } pi->pi_pid = pid; pi->pi_ppid = ppid; pi->pi_exited = false; pi->pi_exitstatus = 0xbaad; /* Recognizably invalid value */ return pi; }
static void inititems(void) { if (testsem==NULL) { testsem = sem_create("testsem", 2); if (testsem == NULL) { panic("synchtest: sem_create failed\n"); } } if (testlock==NULL) { testlock = lock_create("testlock"); if (testlock == NULL) { panic("synchtest: lock_create failed\n"); } } if (testcv==NULL) { testcv = cv_create("testlock"); if (testcv == NULL) { panic("synchtest: cv_create failed\n"); } } if (donesem==NULL) { donesem = sem_create("donesem", 0); if (donesem == NULL) { panic("synchtest: sem_create failed\n"); } } }
pid_t newprocess(pid_t parent) { struct process *newproc; pid_t newpid; struct cv *newcv; newproc = (struct process *) kmalloc(sizeof(struct process)); if (newproc==NULL) return (pid_t) -ENOMEM; newcv = cv_create("childexit"); if (newcv==NULL) { kfree(newproc); return (pid_t) -ENOMEM; } newproc->filetable = NULL; newproc->parentpid = parent; newproc->childexit = newcv; newproc->exited = 0; lock_acquire(proctable_lock); newpid = array_getnum(proctable); array_add(proctable, newproc); lock_release(proctable_lock); return newpid+1; }
void initialize_pid(struct thread *thr,pid_t processid) { if(curthread!=NULL) lock_acquire(pid_lock); struct process_control *p_array; p_array=kmalloc(sizeof(struct process_control)); thr->t_pid=processid; p_array->parent_id=-1; p_array->childlist=NULL; p_array->exit_code=-1; p_array->exit_status=false; p_array->mythread=thr; p_array->waitstatus=false; p_array->process_sem = sem_create(thr->t_name,0); //Create the lock and CV p_array->process_lock=lock_create(thr->t_name); p_array->process_cv = cv_create(thr->t_name); //Copy back into the thread process_array[processid]=p_array; if(curthread!=NULL) lock_release(pid_lock); }
/* * The simulation driver will call this function once before starting * the simulation * * You can use it to initialize synchronization and other variables. * */ void intersection_sync_init(void) { /* replace this default implementation with your own implementation */ inservice=0; wait_total=0; intersectionSem = sem_create("intersectionSem",1); if (intersectionSem == NULL) { panic("could not create intersection semaphore"); } mutex=lock_create("intersection lock"); if(mutex==NULL) { panic("could not create intersection lock"); } int i; for(i=0;i<4;i++) { CV[i]=cv_create("condition varaible"); if(CV[i]==NULL) { panic("could not create condition variable"); } } return; }
void daemon_init(void) { int err; char *daemon_name; if (!USE_DAEMON) { return; } daemon_name = kstrdup("writeback daemon:"); if (daemon_name == NULL) { panic("daemon_init: could not launch thread"); } daemon.d_cv = cv_create("daemon cv"); if (daemon.d_cv == NULL) { panic("daemon_init: could not launch thread"); } daemon.d_lock = lock_create("daemon lock"); if (daemon.d_lock == NULL) { panic("daemon_init: could not launch thread"); } daemon.d_awake = true; err = thread_fork(daemon_name, NULL, daemon_thread, NULL, 0); if (err) { panic("daemon_init: could not launch thread"); } }
static struct ipc_port * ipc_port_alloc(void) { struct ipc_port *ipcp; struct task *task; int error; task = current_task(); ipcp = pool_allocate(&ipc_port_pool); mutex_init(&ipcp->ipcp_mutex, "IPC Port", MUTEX_FLAG_DEFAULT); ipcp->ipcp_cv = cv_create(&ipcp->ipcp_mutex); ipcp->ipcp_port = IPC_PORT_UNKNOWN; ipcp->ipcp_flags = IPC_PORT_FLAG_NEW; TAILQ_INIT(&ipcp->ipcp_msgs); BTREE_NODE_INIT(&ipcp->ipcp_link); BTREE_ROOT_INIT(&ipcp->ipcp_rights); /* * Insert a receive right. */ error = ipc_port_right_insert(ipcp, task, IPC_PORT_RIGHT_RECEIVE); if (error != 0) panic("%s: ipc_port_right_insert failed: %m", __func__, error); return (ipcp); }
void whalemating_init() { male_lock = lock_create("male"); female_lock = lock_create("female"); match_maker_lock = lock_create("match_maker"); thread_count_lock = lock_create("counter"); thread_count_cv = cv_create("count_cv"); return; }
static void init(){ if (cats == NULL){ cats = cv_create("Cats"); } if (mouse == NULL){ mouse = cv_create("mouse"); } if (catEatLock == NULL){ catEatLock = lock_create("catEatLock"); } if (mouseEatLock == NULL){ mouseEatLock = lock_create("mouseEatLock"); } if (bowlLock == NULL){ bowlLock = lock_create("bowlLock"); } }
void whalemating_init() { hold=lock_create("My lock"); male_sem=sem_create("Male Semaphore",0); female_sem=sem_create("Female Semaphore",0); mate_cv=cv_create("mating cv"); male_count=0; female_count=0; return; }
int ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond, ldap_pvt_thread_mutex_t *mutex ) { if ( ! cond->lcv_created ) { cv_create( &cond->lcv_cv, *mutex ); cond->lcv_created = 1; } return( cv_wait( cond->lcv_cv ) ); }
static void init_members(member *mems, int length, const char *name) { struct lock *common_lock = lock_create(name); struct cv *common_cv = cv_create(name); for (int i = 0; i < length; i++) { mems[i].m_name = NULL; mems[i].m_cv = common_cv; mems[i].m_lock = common_lock; } }
struct rwlock * rwlock_create(const char *name) { struct rwlock *rwlock; rwlock = kmalloc(sizeof(struct rwlock)); if (rwlock == NULL) { return NULL; } rwlock->rwlock_name = kstrdup(name); if (rwlock->rwlock_name == NULL) { kfree(rwlock); return NULL; } rwlock->write_cv = cv_create(rwlock->rwlock_name); if (rwlock->write_cv == NULL) { cv_destroy(rwlock->write_cv); return NULL; } rwlock->read_cv = cv_create(rwlock->rwlock_name); if (rwlock->read_cv == NULL) { cv_destroy(rwlock->read_cv); return NULL; } rwlock->lk = lock_create(rwlock->rwlock_name); if (rwlock->lk == NULL) { lock_destroy(rwlock->lk); return NULL; } rwlock->hold_readers = 0; rwlock->is_writing = 0; rwlock->num_readers = 0; return rwlock; }
/* * Create a pidinfo structure for the specified pid. */ static struct pidinfo * pidinfo_create(pid_t pid, pid_t ppid) { struct pidinfo *pi; KASSERT(pid != INVALID_PID); pi = kmalloc(sizeof(struct pidinfo)); if (pi==NULL) { return NULL; } pi->pi_cv = cv_create("pidinfo cv"); if (pi->pi_cv == NULL) { kfree(pi); return NULL; } /* Initialize pi_signal_cv. */ pi->pi_signal_cv = cv_create("pidinfo signal cv"); if (pi->pi_signal_cv == NULL) { kfree(pi); return NULL; } pi->pi_pid = pid; pi->pi_ppid = ppid; pi->pi_exited = false; pi->pi_exitstatus = 0xbaad; /* Recognizably invalid value */ pi->detached = false; pi->sigkill = false; pi->sigstop = false; pi->sigcont = false; pi->waitingthreads = 0; return pi; }
void stoplight_init() { intersect_cv=cv_create("Intersection Condition Variable"); if(intersect_cv==NULL) { ///return NULL; panic("condition variable not created"); } intersect_lock=lock_create("A lock on the intersection"); if(intersect_lock==NULL) { //return NULL; panic("Lock could not be created"); } return; }
/* * Thread initialization. */ struct thread * thread_bootstrap(void) { struct thread lock_exit = lock_create("lock_exit"); cv_parent_queue = cv_create("parent_queue"); /* Create the DAta structures we need. */ sleepers = array_create(); if (sleepers==NULL) { panic("Cannot create sleepers array\n"); } zombies = array_create(); if (zombies==NULL) { panic("Cannot create zombies array\n"); } /* * Create the thread structure for the first thread * (the one that's already running) */ me = thread_create("<boot/menu>"); if (me==NULL) { panic("thread_bootstrap: Out of memory\n"); } /* * Leave me->t_stack NULL. This means we're using the boot stack, * which can't be freed. */ /* Initialize the first thread's pcb */ md_initpcb0(&me->t_pcb); /* Set curthread */ curthread = me; /* Number of threads starts at 1 */ numthreads = 1; /* Done */ return me; }
int cvtest2(int nargs, char **args) { unsigned i; int result; (void)nargs; (void)args; for (i=0; i<NCVS; i++) { testlocks[i] = lock_create("cvtest2 lock"); testcvs[i] = cv_create("cvtest2 cv"); } gatesem = sem_create("gatesem", 0); exitsem = sem_create("exitsem", 0); kprintf("cvtest2...\n"); result = thread_fork("cvtest2", NULL, sleepthread, NULL, 0); if (result) { panic("cvtest2: thread_fork failed\n"); } result = thread_fork("cvtest2", NULL, wakethread, NULL, 0); if (result) { panic("cvtest2: thread_fork failed\n"); } P(exitsem); P(exitsem); sem_destroy(exitsem); sem_destroy(gatesem); exitsem = gatesem = NULL; for (i=0; i<NCVS; i++) { lock_destroy(testlocks[i]); cv_destroy(testcvs[i]); testlocks[i] = NULL; testcvs[i] = NULL; } kprintf("cvtest2 done\n"); return 0; }
void whalemating_init() { //extern int male_head, male_tail, female_head, female_tail; //extern struct lock *pop_lock; //extern struct cv *maker_cv; male_head = male_tail = 0; female_head = female_tail = 0; pop_lock = lock_create("population"); if(pop_lock == NULL) { panic("whalemating: lock failed\n"); } maker_cv = cv_create("maker cv"); if(maker_cv == NULL) { panic("whalemating: condition variable failed\n"); } //return; }
struct kitchen *kitchen_create() { int i; // Create the top-level struct struct kitchen *k = kmalloc(sizeof(struct kitchen)); if (k == NULL) { return NULL; } // Construct the bowl lock array k->bowl_locks = kmalloc(NumBowls * sizeof(struct lock *)); if (k->bowl_locks == NULL) { kfree(k); return NULL; } // Construct each bowl lock for (i = 0; i < NumBowls; i++) { k->bowl_locks[i] = lock_create("bowl"); } // Construct the entrance lock k->kitchen_lock = lock_create("enter"); // Construct the kitchen cv k->kitchen_cv = cv_create("kitchen"); // Construct the group queue k->group_list = q_create(1); // Initialize the current_creature flag k->current_creature = 2; // Initialize the counter k->creature_count = 0; return k; }
int hungrybirds() { int n; // number of baby birds kprintf("Making mama bird...\n"); // Create the mama condition variable mama = cv_create("mamacv"); // Create the bowl lock bowl_lock = lock_create("bowl"); // Create the mama bird kprintf("Forking mama bird...\n"); thread_fork("Mama_thread", 0, 0, &mama_bird, NULL); // Put some food in the bowl int f = random() % MAXFOOD; // Have at least some reasonable amount of starting food if (f < 3) f = 3; // Create a random number of baby birds n = random() % MAXBABIES; if (n < 2) n = 2; // At least have a couple of babies! kprintf("Making %d babies...\n", n); int i; for (i = 0; i < n; i++) { kprintf("Made a baby bird.\n"); thread_fork("Baby_thread", 0, 0, &baby_bird, NULL); } return 0; }
/* * Create a pidinfo structure for the specified pid. */ static struct pidinfo * pidinfo_create(pid_t pid, pid_t ppid) { struct pidinfo *pi; struct pidinfo *ppi; if(ppid != INVALID_PID){ ppi = pi_get(ppid); ppi->kids[ppi->kids_tail] = pid; ppi->kids_tail++; } KASSERT(pid != INVALID_PID); pi = kmalloc(sizeof(struct pidinfo)); if (pi==NULL) { return NULL; } pi->pi_cv = cv_create("pidinfo cv"); if (pi->pi_cv == NULL) { kfree(pi); return NULL; } pi->pi_pid = pid; pi->pi_ppid = ppid; pi->pi_exited = false; pi->pi_exitstatus = 0xbaad; /* Recognizably invalid value */ pi->joined_pid = 0; pi->detached = false; pi->kids_tail = 0; return pi; }
void stoplight_init() { // @forkloop // // int quad_status[4]; // struct lock *quad_lock; // struct cv *quad_cv; quad_status[0]=quad_status[1]=quad_status[2]=quad_status[3]=0; quad_lock = lock_create("quadrant lock"); if(quad_lock == NULL) { panic("stoplight: lock created failure.\n"); } quad_cv = cv_create("quadrant cv"); if(quad_cv == NULL) { panic("stoplight: cv created failure.\n"); } /* struct lock lock_list[4]; char lock_name[6]; for(int i=0;i<4;i++) { snprintf(lock_name, sizeof(lock_name), "lock%d\0", i); lock_list[i] = lock_create(lock_name); if(lock_list[i] == NULL) { panic("stoplight: lock created failure.\n"); } } //return; */ }