TACHE Conso2(void) { puts("------> Start Conso 2"); while(1) { puts("------> Conso 2 : puis-je ?"); s_wait(mySem2); printf("Conso 2 : j'ai mangé : %d\n",field.file[field.deb]); field.deb = (field.deb+1) % MAX_TACHES; s_signal(mySem); puts("------> Conso 2 : go"); } fin_tache(); }
void a_switch_to(void) { static bool not_first; while (not_first); printf("%s: Received call from Receiver\n", get_instance_name()); /* OK, now let's proceed to try to trash our reply cap. You can more or * less read execution in a straight line from here as each function calls * the next. */ printf("%s: Acquiring mutex...\n", get_instance_name()); m_lock(); printf("%s: Acquiring semaphore...\n", get_instance_name()); s_wait(); /* Trigger some more calls on the original endpoint, just in case this is * not correctly handled. */ p1_emit(); p2_emit(); printf("%s: Taking first hop...\n", get_instance_name()); b1_switch_to(); printf("%s: Taking second hop...\n", get_instance_name()); c1_switch_to(); printf("%s: Taking third hop...\n", get_instance_name()); d1_switch_to(); printf("%s: Taking fourth (external) hop...\n", get_instance_name()); e_switch_to(); printf("%s: Releasing mutex...\n", get_instance_name()); m_unlock(); printf("%s: Releasing semaphore...\n", get_instance_name()); s_post(); printf("%s: Returning (moment of truth)...\n", get_instance_name()); /* Prevent future output that can confuse users. */ if (!not_first) { not_first = true; } }
TACHE Prod(void) { puts("------> Start Prod"); while(1) { puts("------> Prod : puis-je?"); s_wait(mySem); puts("------> Prod : je prod"); field.file[field.fin] = field.fin; field.fin = (field.fin+1) % MAX_TACHES; puts("------> Prod : go"); s_signal(mySem2); s_signal(mySem2); s_signal(mySem2); } fin_tache(); }
static void s_atexit_handler(void) { if (likely(__sync_fetch_and_add(&s_is_exit_handler_called, 1) == 0)) { gallus_result_t r; r = s_trylock(); if (likely(r == GALLUS_RESULT_OK)) { bool is_finished_cleanly = false; if (s_n_modules > 0) { recheck: mbar(); if (s_gstate == MODULE_GLOBAL_STATE_UNKNOWN) { is_finished_cleanly = true; } else if (s_gstate == MODULE_GLOBAL_STATE_STARTED) { (void)global_state_request_shutdown(SHUTDOWN_RIGHT_NOW); } else if (s_gstate != MODULE_GLOBAL_STATE_FINALIZED) { r = s_wait(100LL * 1000LL * 1000LL); if (r == GALLUS_RESULT_OK) { goto recheck; } else if (r == GALLUS_RESULT_TIMEDOUT) { gallus_msg_warning("Module finalization seems not completed.\n"); } else { gallus_perror(r); gallus_msg_error("module finalization wait failed.\n"); } } else { is_finished_cleanly = true; } } if (is_finished_cleanly == true) { s_is_unloading = true; mbar(); } s_unlock(); } else if (r == GALLUS_RESULT_BUSY) { /* * The lock failure. Snoop s_gstate anyway. Note that it's safe * since the modules are always accessesed only by a single * thread and the thread is calling exit(3) at this moment. */ if (s_gstate == MODULE_GLOBAL_STATE_UNKNOWN) { /* * No modules are initialized. Just exit cleanly and let all * the static destructors run. */ s_is_unloading = true; mbar(); } else { if (pthread_self() == s_initializer_tid) { /* * Made sure that this very thread is the module * initializer. So we can safely unlock the lock. */ switch (s_gstate) { case MODULE_GLOBAL_STATE_FINALIZING: case MODULE_GLOBAL_STATE_FINALIZED: case MODULE_GLOBAL_STATE_UNKNOWN: { s_unlock(); /* * Nothing is needed to do. */ break; } case MODULE_GLOBAL_STATE_INITIALIZING: case MODULE_GLOBAL_STATE_INITIALIZED: case MODULE_GLOBAL_STATE_STARTING: { s_unlock(); /* * With this only modules safely finalizable so far are * finalized. */ gallus_module_finalize_all(); break; } case MODULE_GLOBAL_STATE_STARTED: { s_unlock(); (void)global_state_request_shutdown(SHUTDOWN_RIGHT_NOW); break; } case MODULE_GLOBAL_STATE_SHUTTINGDOWN: case MODULE_GLOBAL_STATE_STOPPING: case MODULE_GLOBAL_STATE_WAITING: case MODULE_GLOBAL_STATE_SHUTDOWN: { s_unlock(); /* * There's nothing we can do at this moment. */ break; } default: { s_unlock(); break; } } } else { /* (pthread_self() == s_initializer_tid) */ /* * This menas that a thread other than module initialized is * locking the lock. There's nothing we can do at this moment. */ return; } } /* (s_gstate == MODULE_GLOBAL_STATE_UNKNOWN) */ } } }