TEST(core, Semaphore) { Semaphore s; ASSERT_FALSE(s.wait(10)); s.signal(); ASSERT_TRUE(s.wait(10)); ASSERT_FALSE(s.wait(10)); s.signal(2); ASSERT_TRUE(s.wait(10)); ASSERT_TRUE(s.wait(10)); ASSERT_FALSE(s.wait(10)); std::thread t1([&s]() { ASSERT_FALSE(s.wait(10)); s.wait(); }); std::thread t2([&s]() { std::this_thread::sleep_for(std::chrono::milliseconds(50)); s.signal(2); s.wait(); }); t1.join(); t2.join(); }
void testSimple() { //Some very basic semaphore tests. Semaphore sem; sem.signal(); sem.wait(); testTimedElapsed(sem, 100); sem.signal(); testTimedAvailable(sem); sem.reinit(2); sem.wait(); testTimedAvailable(sem); testTimedElapsed(sem, 5); }
// returns false if queue was full bool tryPut(T t){ if (queue.bounded_push(t)) { ready.signal(); return true; } return false; }
BigRealResourcePool &getInstance() { m_gate.wait(); if(m_instance == NULL) { m_instance = new BigRealResourcePool; TRACE_NEW(m_instance); } m_gate.signal(); return *m_instance; }
virtual void run() { Looper::prepare(); sLooper2 = Looper::myLooper(); sHandler2 = new Handler2(); printf("Looper 2 uses thread %d\n", (int32_t) pthread_self()); sSemaphore2.signal(); Looper::loop(); }
simple_queue(unsigned int queue_size) { element_count = queue_size; elements = new _et[element_count]; free_space.signal(element_count); active_buffers = 0; first = 0; last = 0; }
void barber(){ while(true){ semCustomers.wait(); bool blockBarber = false; if(cntCustomers == 0) blockBarber = true; semCustomers.signal(); if(blockBarber) sleep.wait(); mutex.signal(); semCustomers.wait(); cntCustomers--; semCustomers.signal(); } }
void customer(){ semCustomers.wait(); if(cntCustomers == N){ semCustomers.signal(); return; } if(cntCustomers == 0){ cntCustomers++; sleep.signal(); } else{ cntCustomers++; } semCustomers.signal(); mutex.wait(); }
void pop (_et &element) { data_avail.wait(); c_region.enter(); element = elements[first]; first = (first + 1) % element_count; active_buffers--; c_region.leave(); free_space.signal(); }
void worker_done_with_task() { // Mark that the worker is done with the task. // The worker is not allowed to read the state variables after this line. uint not_finished = (uint) Atomic::add(-1, (volatile jint*)&_not_finished); // The last worker signals to the coordinator that all work is completed. if (not_finished == 0) { _end_semaphore->signal(); } }
int ReceiveThread::run() { ISocket * socket = ISocket::create(3456); ISocket * client = socket->accept(); StringBuffer result; readResults(client, parallelBlocked, false, result, nullptr, 0); client->Release(); socket->Release(); finishedReading.signal(); return 0; }
void push(const _et &element) { free_space.wait(); c_region.enter(); int next = (last + 1) % element_count; elements[last] = element; last = next; active_buffers++; c_region.leave(); data_avail.signal(); }
void testSimple() { //Very basic semaphore stress tests. Semaphore sem; sem.signal(); if (!sem.wait(1000)) { VStringBuffer errMsg("Semaphore stalled (%s:%s)", sanitizeSourceFile(__FILE__), __LINE__); CPPUNIT_FAIL(errMsg.str()); } testTimedElapsed(sem, 5, 1000); }
int main(int argc, char **argv) { char buffer[TAM_BUFFER]; if (argc != 2) { strcpy (buffer, "Error: Cantidad de parametros invalida\n"); write (fileno(stderr),buffer, strlen(buffer)); exit(1); } int cantProcesos = 0; sscanf(argv[1] , "%d", &cantProcesos); // Creando semaforo de control de acceso a la memoria compartida Semaphore semControl = Semaphore(); semControl.createSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1); semControl.initializeSemaphore(0, 1); // Creando semaforos de control de los procesos Semaphore semProductores = Semaphore(); semProductores.createSemaphore((char *)DIRECTORY, ID_SEMPRODUCTORES, cantProcesos); for (int nroSemaforo = 0; nroSemaforo < cantProcesos; nroSemaforo++) { semProductores.initializeSemaphore(nroSemaforo, 1); } // Creando la memoria compartida CountingSharedMemory shMem = CountingSharedMemory(); shMem.createSharedMemory((char *)DIRECTORY, ID_SHMEM); semControl.wait(0); { int p = 0; shMem.writeInfo(&p); } semControl.signal(0); for (int i = 0; i < cantProcesos; i++) { pid_t pid = fork(); if (pid == 0) { char nroProductor[TAM_BUFFER]; sprintf(nroProductor,"%d",i); execlp("./productor", "productor", nroProductor, argv[1], (char *) 0); sprintf(buffer, "Launcher Error: %s\n", strerror(errno)); write(fileno(stdout), buffer, strlen(buffer)); } //sleep (1); } sprintf(buffer, "Launcher Terminado \n"); write(fileno(stdout), buffer, strlen(buffer)); return 0; }
static void addDebugLine(_In_z_ _Printf_format_string_ TCHAR const * const format, ...) { static Semaphore gate; static TCHAR *mode = _T("w"); gate.wait(); FILE *f = FOPEN(_T("c:\\temp\\semaphore.log"),mode); mode = _T("a"); va_list argptr; va_start(argptr,format); _vftprintf(f, format, argptr); va_end(argptr); fclose(f); gate.signal(); }
void subsort(unsigned s, unsigned n) { do { sJobItem *qi; while (n>PARALLEL_GRANULARITY) { unsigned r1; unsigned r2; partition(s, n, r1, r2); unsigned n2 = n+s-r2; if (r1==s) { n = n2; s = r2; } else { if (n2!=0) { qi = new sJobItem; qi->num = n2; qi->start = r2; NonReentrantSpinBlock block(joblock); jobq.enqueue(qi); if (waiting) { jobqsem.signal(waiting); waiting = 0; } } n = r1-s; } } serialsort(s,n); NonReentrantSpinBlock block(joblock); if (waiting==numsubthreads) { // well we are done so are rest done = true; jobqsem.signal(waiting); break; } } while(waitForWork(s,n)); }
bool push(const _et &element,long timeout) { if (free_space.wait(timeout) ) { c_region.enter(); int next = (last + 1) % element_count; elements[last] = element; last = next; active_buffers++; c_region.leave(); data_avail.signal(); return true; } return false; }
inline int wait() { int ret = 0; barlock.lock(); current += 1; if(current == count) { ret = PTHREAD_BARRIER_SERIAL_THREAD; for(int i=0; i<count; i++) { barrier1.signal(); } } barlock.unlock(); barrier1.wait(); // wait for n threads to arrive barlock.lock(); current -= 1; if(current == 0) { for(int i=0; i<count; i++) { barrier2.signal(); } } barlock.unlock(); barrier2.wait(); return ret; }
inline bool wait() { bool ret = false; barlock.lock(); current += 1; if(current == count) { ret = true; for(int i=0; i<count;i++) { barrier1.signal(); } } barlock.unlock(); barrier1.wait(); // wait for n threads to arrive barlock.lock(); current -= 1; if(current == 0) { for(int i=0;i<count;i++) { barrier2.signal(); } } barlock.unlock(); barrier2.wait(); return ret; }
void coordinator_execute_on_workers(AbstractGangTask* task, uint num_workers) { // No workers are allowed to read the state variables until they have been signaled. _task = task; _not_finished = num_workers; // Dispatch 'num_workers' number of tasks. _start_semaphore->signal(num_workers); // Wait for the last worker to signal the coordinator. _end_semaphore->wait(); // No workers are allowed to read the state variables after the coordinator has been signaled. assert(_not_finished == 0, "%d not finished workers?", _not_finished); _task = NULL; _started = 0; }
void unlock(SessionId owner) { sect.enter(); if (exclusivenest) { exclusivenest--; if (exclusivenest) { // still locked assertex(owners.item(0)==owner); sect.leave(); return; } } verifyex(owners.zap(owner)); if (owners.ordinality()==0) { exclusivenest = 0; if (waiting) { sem.signal(waiting); waiting = 0; } } else { assertex(!exclusivenest); } sect.leave(); }
bool waitForWork(unsigned &s,unsigned &n) { NonReentrantSpinBlock block(joblock); while (!done) { sJobItem *qi = jobq.dequeue(); if (qi) { s = qi->start; n = qi->num; delete qi; return true; } if (waiting==numsubthreads) { // well we know we are done and so are rest so exit done = true; jobqsem.signal(waiting); break; } waiting++; NonReentrantSpinUnblock unblock(joblock); jobqsem.wait(); } s = 0; // remove uninitialised variable warnings n = 0; return false; }
~Schedule() { stopping = true; semSchedule.signal(); join(); }
int main(int argc, char** argv) { /* Se crean e inician todos los ipc necesarios para * el funcionamiento del proceso. */ ComunicacionRobot5MessageQueue colaComunicacionRobot5 = ComunicacionRobot5MessageQueue(); PedidosAgvMessageQueue colaPedidos = PedidosAgvMessageQueue(); BufferCanastoSharedMemory bufferCanasto[3]; Semaphore semaforoAccesoBufferAgv; Semaphore semaforoBloqueoAgv; try { iniciarIPC(colaComunicacionRobot5, colaPedidos, bufferCanasto, semaforoAccesoBufferAgv, semaforoBloqueoAgv); } catch (IPCException const& ex) { char buffer[TAM_BUFFER]; sprintf (buffer, "Controlador Robot 5 - AGV: Error: %s\n", ex.what()); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } char buffer[TAM_BUFFER]; sprintf(buffer, "Controlador Robot 5 - AGV: Iniciando.\n"); write(fileno(stdout), buffer, strlen(buffer)); bool deboSeguir = true; while (deboSeguir) { try { /* Obtengo un pedido de alguno de los AGV */ sprintf(buffer, "Controlador Robot 5 - AGV: Esperando un pedido por parte de un AGV.\n"); write(fileno(stdout), buffer, strlen(buffer)); MensajePedidoAgv *nuevoPedido; colaPedidos.recibirPedidoAgv(TIPO_PEDIDO_CANASTO, nuevoPedido); sprintf(buffer, "Controlador Robot 5 - AGV: Recibió un pedido de un AGV.\n"); write(fileno(stdout), buffer, strlen(buffer)); /* Le envio el pedido al robot 5 Aplicacion */ PedidoRobot5 pedidoRobot5; pedidoRobot5.pedidoCanasto = (*nuevoPedido).pedidoCanasto; pedidoRobot5.tipo = PEDIDO_CANASTO; MensajePedidoRobot5 mensajePedidoRobot5; mensajePedidoRobot5.mtype = TIPO_PEDIDO_ROBOT_5; mensajePedidoRobot5.pedidoRobot5 = pedidoRobot5; sprintf(buffer, "Controlador Robot 5 - AGV: Le envio un pedido de canasto al robot 5.\n"); write(fileno(stdout), buffer, strlen(buffer)); colaComunicacionRobot5.enviarPedidoRobot5(mensajePedidoRobot5); /* Me quedo esperando la respuesta del robot 5 */ MensajeRespuestaCanasto mensajeRespuestaCanasto; colaComunicacionRobot5.recibirCanasto(TIPO_MENSAJE_RESPUESTA_CANASTO_ROBOT_5, &mensajeRespuestaCanasto); sprintf(buffer, "Controlador Robot 5 - AGV: Recibió la respuesta del robot 5 para el AGV %d.\n",mensajeRespuestaCanasto.idAgv); write(fileno(stdout), buffer, strlen(buffer)); /* Una vez recibido el canasto requerido, se lo envio al agv correspondiente. * Intento acceder al buffer del agv al que va destinado al pedido. */ semaforoAccesoBufferAgv.wait(mensajeRespuestaCanasto.idAgv); { sprintf(buffer, "Controlador Robot 5 - AGV: Accedo al buffer del canasto para el AGV: %d.\n",mensajeRespuestaCanasto.idAgv); write(fileno(stdout), buffer, strlen(buffer)); /* Una vez obtenido al acceso, dejo el canasto. */ bufferCanasto[mensajeRespuestaCanasto.idAgv - 1].writeInfo(&mensajeRespuestaCanasto.canasto); } /* Libero al AGV para que este retire el canasto */ semaforoBloqueoAgv.signal(mensajeRespuestaCanasto.idAgv); sprintf(buffer, "Controlador Robot 5 - AGV: Libero al AGV %d.\n",mensajeRespuestaCanasto.idAgv); write(fileno(stdout), buffer, strlen(buffer)); /* Libero el buffer del canasto */ semaforoAccesoBufferAgv.signal(mensajeRespuestaCanasto.idAgv); } catch (IPCException const& ex) { char buffer[TAM_BUFFER]; sprintf(buffer, "Controlador Robot 5 - AGV:Error: %s\n", ex.what()); write(fileno(stderr), buffer, strlen(buffer)); exit(-1); } } return 0; }
void next() { hold.signal(); }
void kill() // called on message thread { terminate = true; hold.signal(); }
int main(int argc, char **argv) { char buffer[TAM_BUFFER]; if (argc != 2) { strcpy (buffer, "Error Puerta Entrada: Cantidad de parametros invalida\n"); write (fileno(stderr),buffer, strlen(buffer)); exit(1); } srand (time(NULL)); int totalPuerta = 0; int nroPuerta = 0; sscanf(argv[1] , "%d", &nroPuerta); sprintf(buffer, "Puerta Entrada: %d Iniciando\n", nroPuerta); write(fileno(stdout), buffer, strlen(buffer)); // Creando semaforo de control de acceso a la memoria compartida Semaphore semControl = Semaphore(); if (semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) { sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semaforo de control\n", nroPuerta); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } // Obteniendo memoria compartida InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory(); if (shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) { sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la memoria\n", nroPuerta); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } bool deboSeguir = true; while (deboSeguir) { int dormir = rand() % 5 + 1; sprintf (buffer, "Puerta Entrada: %d Durmiendo por %d segundos\n", nroPuerta, dormir); write (fileno(stdout),buffer, strlen(buffer)); usleep(dormir*1000*1000); totalPuerta++; sprintf (buffer, "Puerta Entrada: %d Llego la persona %d\n", nroPuerta, totalPuerta); write (fileno(stdout),buffer, strlen(buffer)); int semaphoreOperation = semControl.wait(0); if (semaphoreOperation == -1) exit(-1); { InfoMuseo *info = shMem.readInfo(); if (! (*info).abierto) { sprintf (buffer, "Puerta Entrada: %d El museo esta CERRADO, la persona %d debe irse\n", nroPuerta,totalPuerta); write (fileno(stdout),buffer, strlen(buffer)); } else { if ((*info).cantidad == (*info).cantidadMaxima) { sprintf (buffer, "Puerta Entrada: %d El museo esta LLENO, la persona %d debe irse\n", nroPuerta,totalPuerta); write (fileno(stdout),buffer, strlen(buffer)); } else { sprintf (buffer, "Puerta Entrada: %d La persona %d ingresa al museo\n", nroPuerta,totalPuerta); write (fileno(stdout),buffer, strlen(buffer)); (*info).cantidad++; (*info).total++; shMem.writeInfo(info); } } } semControl.signal(0); if (semaphoreOperation == -1) exit(-1); } return 0; }
void processMessage(CMessageBuffer &mb) { ICoven &coven=queryCoven(); SessionId id; int fn; mb.read(fn); switch (fn) { case MSR_REGISTER_PROCESS_SESSION: { acceptConnections.wait(); acceptConnections.signal(); Owned<INode> node(deserializeINode(mb)); Owned<INode> servernode(deserializeINode(mb)); // hopefully me, but not if forwarded int role=0; if (mb.length()-mb.getPos()>=sizeof(role)) { // a capability block present mb.read(role); if (!manager.authorizeConnection(role,false)) { SocketEndpoint sender = mb.getSender(); mb.clear(); coven.reply(mb); MilliSleep(100+getRandom()%1000); // Causes client to 'work' for a short time. Owned<INode> node = createINode(sender); coven.disconnect(node); break; } #ifdef _DEBUG StringBuffer eps; PROGLOG("Connection to %s authorized",mb.getSender().getUrlStr(eps).str()); #endif } IGroup *covengrp; id = manager.registerClientProcess(node.get(),covengrp,(DaliClientRole)role); mb.clear().append(id); if (covengrp->rank(servernode)==RANK_NULL) { // must have been redirected covengrp->Release(); // no good, so just use one we know about (may use something more sophisticated later) INode *na = servernode.get(); covengrp = createIGroup(1, &na); } covengrp->serialize(mb); covengrp->Release(); coven.reply(mb); } break; case MSR_SECONDARY_REGISTER_PROCESS_SESSION: { mb.read(id); Owned<INode> node (deserializeINode(mb)); int role; mb.read(role); manager.addProcessSession(id,node.get(),(DaliClientRole)role); mb.clear(); coven.reply(mb); } break; case MSR_REGISTER_SESSION: { SecurityToken tok; SessionId parentid; mb.read(tok).read(parentid); SessionId id = manager.registerSession(tok,parentid); mb.clear().append(id); coven.reply(mb); } break; case MSR_SECONDARY_REGISTER_SESSION: { mb.read(id); manager.addSession(id); mb.clear(); coven.reply(mb); } break; case MSR_LOOKUP_PROCESS_SESSION: { // looks up from node or from id Owned<INode> node (deserializeINode(mb)); if (node->endpoint().isNull()&&(mb.length()-mb.getPos()>=sizeof(id))) { mb.read(id); INode *n = manager.getProcessSessionNode(id); if (n) node.setown(n); node->serialize(mb.clear()); } else { id = manager.lookupProcessSession(node.get()); mb.clear().append(id); } coven.reply(mb); } break; case MSR_STOP_SESSION: { SessionId sessid; bool failed; mb.read(sessid).read(failed); manager.stopSession(sessid,failed); mb.clear(); coven.reply(mb); } break; case MSR_LOOKUP_LDAP_PERMISSIONS: { StringAttr key; StringAttr obj; Owned<IUserDescriptor> udesc=createUserDescriptor(); StringAttr username; StringAttr passwordenc; mb.read(key).read(obj); udesc->deserialize(mb); #ifndef _NO_DALIUSER_STACKTRACE //following debug code to be removed StringBuffer sb; udesc->getUserName(sb); if (0==sb.length()) { DBGLOG("UNEXPECTED USER (NULL) in dasess.cpp CSessionRequestServer::processMessage() line %d", __LINE__); } #endif unsigned auditflags = 0; if (mb.length()-mb.getPos()>=sizeof(auditflags)) mb.read(auditflags); int err = 0; int ret=manager.getPermissionsLDAP(key,obj,udesc,auditflags,&err); mb.clear().append(ret); if (err) mb.append(err); coven.reply(mb); } break; } }
void ready() { acceptConnections.signal(); }
int main(int argc, char **argv) { char buffer[TAM_BUFFER]; if (argc != 3) { strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida\n Uso:\n ./launcher [CANT BUSES] [CANT PERSONAS]\n"); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } int cantBuses = 0; sscanf(argv[1] , "%d", &cantBuses); if (cantBuses > MAX_BUSES) { sprintf (buffer, "Launcher: Error: Cantidad de buses debe ser menor que %d\n", MAX_BUSES); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } int cantPersonas = 0; sscanf(argv[2] , "%d", &cantPersonas); sprintf(buffer, "Launcher: Cantidad buses: %d Cantidad Personas: %d\n", cantBuses, cantPersonas); write(fileno(stdout), buffer, strlen(buffer)); Semaphore semControlSala = Semaphore(); Semaphore semPuerta = Semaphore(); Semaphore semBuses = Semaphore(); IntercambioMessageQueue intercambioMessageQueue = IntercambioMessageQueue(); InfoSalaSharedMemory shMemSala = InfoSalaSharedMemory(); try { // Creando semaforo de control de acceso a la memoria compartida Sala semControlSala.createSemaphore((char *)DIRECTORY, ID_SEM_CONTROL_SALA, 1); semControlSala.initializeSemaphore(0, 1); // Creando semaforo de bloqueo de la puerta semPuerta.createSemaphore((char *)DIRECTORY, ID_SEM_PUERTA, 1); semPuerta.initializeSemaphore(0, 0); // Creando semaforo de bloqueo de buses semBuses.createSemaphore((char *)DIRECTORY, ID_SEM_BUSES, cantBuses); for (int i = 0; i < cantBuses; ++i) { semBuses.initializeSemaphore(i, 0); } for (int i = 0; i < cantBuses; ++i) { semBuses.signal(i); sprintf(buffer, "Launcher: Probando sem bus: %d\n", i); write(fileno(stdout), buffer, strlen(buffer)); semBuses.wait(i); sprintf(buffer, "Launcher 2: Probando sem bus: %d\n", i); write(fileno(stdout), buffer, strlen(buffer)); } // Creando la cola de mensajes de intercambio intercambioMessageQueue.create((char*)DIRECTORY, ID_COLA_PERSONAS); // Creando memoria compartida Sala shMemSala.createSharedMemory((char *)DIRECTORY, ID_SHMEM_SALA); InfoSala informacionSala; informacionSala.puertaBloqueada = false; informacionSala.busEnSala = false; for (int i = 0; i < TAM_SALA; ++i) { informacionSala.idPersonas[i] = 0; } for (int i = 0; i < cantBuses; ++i) { informacionSala.busBloqueado[i] = false; } semControlSala.wait(0); { shMemSala.writeInfo(&informacionSala); } semControlSala.signal(0); } catch (IPCException &ex) { sprintf (buffer, "Launcher Error: %s\n", ex.getDescription()); write (fileno(stderr),buffer, strlen(buffer)); exit(-1); } // Creando Buses static char cantidadBuses[TAM_BUFFER]; sprintf(cantidadBuses, "%d",cantBuses); for (int i = 0; i < cantBuses; i++) { static char nroBus[TAM_BUFFER]; sprintf(nroBus,"%d",i); pid_t pid = fork(); if (pid == 0) { execlp("./bus", "bus", nroBus, cantidadBuses, (char *) 0); sprintf(buffer, "Launcher Bus: Error: %s\n", strerror(errno)); write(fileno(stderr), buffer, strlen(buffer)); } } // Creando Puerta pid_t pid = fork(); if (pid == 0) { execlp("./puerta", "puerta", (char *) 0); sprintf(buffer, "Launcher Puerta: Error: %s\n", strerror(errno)); write(fileno(stderr), buffer, strlen(buffer)); } // Creando Productor de personas static char cantidadPersonas[TAM_BUFFER]; sprintf(cantidadPersonas, "%d",cantPersonas); pid = fork(); if (pid == 0) { execlp("./productor", "productor", cantidadPersonas, (char *) 0); sprintf(buffer, "Launcher Productor: Error: %s\n", strerror(errno)); write(fileno(stderr), buffer, strlen(buffer)); } sprintf(buffer, "Launcher: Terminado \n"); write(fileno(stdout), buffer, strlen(buffer)); return 0; }