// remove the entry from the database and then destroy the cacheentry void InternalCCache::remove(const char* key) { log->debug("removing cache entry with key (%s)", key); // lock the cache for writing, which means we know nobody is sitting in find() lock->wrlock(); // grab the entry from the database. ISessionCacheEntry* entry = findi(key); if (!entry) { lock->unlock(); return; } // ok, remove the entry and lock it m_hashtable.erase(key); dynamic_cast<InternalCCacheEntry*>(entry)->lock(); lock->unlock(); // we can release the entry lock because we know we're not in the cache anymore entry->unlock(); // Now delete the entry delete entry; }
void InternalCCache::insert( const char* key, const IApplication* application, const char* client_addr, ShibProfile profile, const char* providerId, SAMLAuthenticationStatement* s, SAMLResponse* r, const IRoleDescriptor* source, time_t created, time_t accessed ) { log->debug("caching new entry for application %s: \"%s\"", application->getId(), key); InternalCCacheEntry* entry = new InternalCCacheEntry( this, key, application, client_addr, profile, providerId, s, r, source, created, accessed ); lock->wrlock(); m_hashtable[key]=entry; lock->unlock(); }
void quitar_partes_barco(list<Casillero>& barco_actual, vector<vector<char> >& tablero_cliente, RWLock& tablero_cliente_rwlock) { tablero_cliente_rwlock.wlock(); for (list<Casillero>::const_iterator casillero = barco_actual.begin(); casillero != barco_actual.end(); casillero++) { tablero_cliente[casillero->fila][casillero->columna] = VACIO; } tablero_cliente_rwlock.wunlock(); barco_actual.clear(); }
Client::Client() { client_no_rw.write_lock(); number = ++client_no; cerr_rw.write_lock(); cerr<<"Client "<<number<<" created"<<endl; cerr_rw.write_unlock(); client_no_rw.write_unlock(); }
void Read() { locker.Lock(RWLock::R); int index = rand() % globalVector.size(); cout << "Reading random index " << index << " value = " << globalVector[index] << endl; locker.UnLock(RWLock::R); }
void Write() { locker.Lock(RWLock::W); int index = globalVector.size(); cout << "Writing index " << index << " value = " << index << endl; globalVector.push_back(index); locker.UnLock(RWLock::W); }
void reader(int id) { rwLock.readLock(); int i = rand() % buffer.size(); int data = buffer[i]; { lock_guard<mutex> lock(outputLock); cout << "reader " << id << " reads buffer[" << i << "] = " << data << endl; } rwLock.readUnLock(); }
s32 sys_rwlock_tryrlock(u32 rw_lock_id) { sys_rwlock.Log("sys_rwlock_tryrlock(rw_lock_id=%d)", rw_lock_id); RWLock* rw; if (!sys_rwlock.CheckId(rw_lock_id, rw)) return CELL_ESRCH; if (!rw->rlock_trylock(GetCurrentPPUThread().GetId())) return CELL_EBUSY; return CELL_OK; }
int sys_rwlock_wunlock(u32 rw_lock_id) { sys_rwlock.Log("sys_rwlock_wunlock(rw_lock_id=%d)", rw_lock_id); RWLock* rw; if (!sys_rwlock.CheckId(rw_lock_id, rw)) return CELL_ESRCH; if (!rw->wlock_unlock(GetCurrentPPUThread().GetId())) return CELL_EPERM; return CELL_OK; }
void *lector(void *p_minumero) { int minumero = *((int *) p_minumero); printf("LECTOR %d QUIERE LEER\n", minumero); lock.rlock(); printf("LECTOR %d LEYENDO\n", minumero); sleep(SLEEP_LECTORES); lock.runlock(); printf("LECTOR %d HA LEIDO\n", minumero); return NULL; }
void writer(int id) { rwLock.writeLock(); int i = rand() % buffer.size(); int data = rand(); buffer[i] = data; { lock_guard<mutex> lock(outputLock); cout << "writer " << id << " writes buffer[" << i << "] = " << data << endl; } rwLock.writeUnLock(); }
void *escritor(void *p_minumero) { int minumero = *((int *) p_minumero); printf("ESCRITOR %d QUIERE ESCRBIR\n", minumero); lock.wlock(); printf("ESCRITOR %d ESCRIBIENDO\n", minumero); sleep(SLEEP_ESCRITORES); lock.wunlock(); printf("ESCRITOR %d HA ESCRITO\n", minumero); return NULL; }
void *read(void *p_args) { int* args = (int*) p_args; if(args[0] == -1) sleep(args[1]); lock.rlock(); sleep(2); printf("Compartida: %d\n", compartida); lock.runlock(); pthread_exit(NULL); }
void *write(void *p_args) { int* args = (int*) p_args; if(args[0] == -1) sleep(args[1]); lock.wlock(); sleep(5); compartida = args[2]; lock.wunlock(); pthread_exit(NULL); }
OSTHREAD_FUNC lock_thread(void *parm){ //int i = (int)(long long) parm; int j; int r; for (j=0; j < LOCK_OPS; ++j){ lock_l.lock(); r = lock_n.next() % 2; lock_counter1 = lock_counter1 ^ r; lock_counter2 = lock_counter2 ^ r; lock_counter3 = lock_counter3 + 1; lock_l.unlock(); } return 0; }
void ClearWarnings(u64 category) { WarningsRWL.LockExclusive(); Array<u64> RemoveList; for (auto kv : WarningsIssued) { if (kv.value == category) { PushBack(RemoveList, kv.key); } } for (auto k : RemoveList) { Remove(WarningsIssued, k); } WarningsRWL.UnlockExclusive(); }
s32 sys_rwlock_trywlock(u32 rw_lock_id) { sys_rwlock.Log("sys_rwlock_trywlock(rw_lock_id=%d)", rw_lock_id); RWLock* rw; if (!sys_rwlock.CheckId(rw_lock_id, rw)) return CELL_ESRCH; const u32 tid = GetCurrentPPUThread().GetId(); if (!rw->wlock_check(tid)) return CELL_EDEADLK; if (!rw->wlock_trylock(tid, false)) return CELL_EBUSY; return CELL_OK; }
/* * Update repository information and return thre repoId, otherwise empty * string. */ void updateRepo(const string &path) { RepoControl repo = RepoControl(path); RepoInfo info; try { repo.open(); } catch (SystemException &e) { WARNING("Failed to open repository %s: %s", path.c_str(), e.what()); return; } RWKey::sp key = infoLock.writeLock(); if (myInfo.hasRepo(repo.getUUID())) { info = myInfo.getRepo(repo.getUUID()); } else { info = RepoInfo(repo.getUUID(), repo.getPath()); } info.updateHead(repo.getHead()); myInfo.updateRepo(repo.getUUID(), info); LOG("Checked %s: %s %s", path.c_str(), repo.getHead().c_str(), repo.getUUID().c_str()); repo.close(); return; }
int enviar_tablero(int socket_fd) { char buf[MENSAJE_MAXIMO+1]; sprintf(buf, "STATUS "); int pos = 7; escribiendo.rlock(); for (unsigned int fila = 0; fila < alto; ++fila) { for (unsigned int col = 0; col < ancho; ++col) { char letra = tablero_palabras[fila][col]; buf[pos] = (letra == VACIO)? '-' : letra; pos++; } } escribiendo.runlock(); buf[pos] = 0; //end of buffer return enviar(socket_fd, buf); }
int main(int argc, char **argv) { uint32_t which_lock; // 1-5 uint32_t which_side; // 0 or 1 uint32_t lock_unlock; // 0 or 1 RWLock *rwlock; name = argv[0]; if (argc != 4) usage(); if (strlen(argv[1]) != 1 || strlen(argv[2]) != 1 || strlen(argv[3]) != 1) usage(); which_lock = atoi(argv[1]); if (which_lock < 1 || which_lock > 5) usage(); if (argv[2][0] == 'r') which_side = 0; else if (argv[2][0] == 'w') which_side = 1; else usage(); if (argv[3][0] == 'l') lock_unlock = 0; else if (argv[3][0] == 'u') lock_unlock = 1; else usage(); rwlock = new RWLock(0x10000 * which_lock); if (which_side == 0) if (lock_unlock == 0) rwlock->read_lock(); else rwlock->read_unlock(); else if (lock_unlock == 0) rwlock->write_lock(); else rwlock->write_unlock(); return 0; }
int get(int key) { // this will do // shared_lock<shared_mutex> lk(s_mtx); rw_lock.ReadLock(); int hash_key = hash(key); int ret = -1; for(auto it = m_map[hash_key].begin(); it != m_map[hash_key].end(); it++) { if((*it).first == key) { ret = (*it).second; break; } } rw_lock.ReadUnLock(); return ret; }
void dumpHosts() { RWKey::sp key = hostsLock.readLock(); map<string, HostInfo *>::iterator it; cout << "=== Begin Hosts ===" << endl; for (it = hosts.begin(); it != hosts.end(); it++) { cout << it->second->getHost() << endl; } cout << "==== End Hosts ====" << endl << endl; }
void put(int key, int val) { // this will do // unique_lock<shared_mutex> lk(s_mtx); int hash_key = hash(key); rw_lock.WriteLock(); for(auto it = m_map[hash_key].begin(); it != m_map[hash_key].end(); it++) { if((*it).first == key) { (*it).first = key; (*it).second = val; rw_lock.WriteUnLock(); return; } } // new key, insert m_map[hash_key].push_front({key, val}); rw_lock.WriteUnLock(); }
void* lector(void * arg){ //++++++++++++++ACA CREAMOS UNA BARRERA PARA QUE TODOS LOS THREADS ESPEREN A QUE SEAN TODOS CREADOS pthread_mutex_lock(&mut); while(!todos_creados){ pthread_cond_wait(&barrera, &mut); } pthread_mutex_unlock(&mut); //++++++++++++++++++++++++++++ int yo = (int)(long)arg; lock_valor.rlock(); printf ("mi tid---->%d leo valor:%d\n", yo, valor ); lock_valor.runlock(); pthread_exit(NULL); return NULL; }
namespace Essence { void ConsolePrint(const char* str) { OutputDebugStringA(str); } Hashmap<u64, u64> WarningsIssued; RWLock WarningsRWL; void FreeWarningsMemory() { FreeMemory(WarningsIssued); } void ClearWarnings(u64 category) { WarningsRWL.LockExclusive(); Array<u64> RemoveList; for (auto kv : WarningsIssued) { if (kv.value == category) { PushBack(RemoveList, kv.key); } } for (auto k : RemoveList) { Remove(WarningsIssued, k); } WarningsRWL.UnlockExclusive(); } void Warning(const char* message, bool one_time, u64 category) { auto hash = Hash::MurmurHash2_64(message, strlen(message), 0); bool print = !one_time; if (one_time) { WarningsRWL.LockShared(); if (!Contains(WarningsIssued, hash)) { print = true; WarningsRWL.UnlockShared(); WarningsRWL.LockExclusive(); WarningsIssued[hash] = category; WarningsRWL.UnlockExclusive(); } else { WarningsRWL.UnlockShared(); } } if (print) { ConsolePrint("WARNING: "); ConsolePrint(message); } } }
void updateHost(KVSerializer &kv, const string &srcIp) { RWKey::sp key = hostsLock.writeLock(); map<string, HostInfo *>::iterator it; string hostId = kv.getStr("hostId"); // Update it = hosts.find(hostId); if (it == hosts.end()) { hosts[hostId] = new HostInfo(hostId, kv.getStr("cluster")); } hosts[hostId]->update(kv); hosts[hostId]->setPreferredIp(srcIp); }
string generate() { RWKey::sp key = infoLock.readLock(); char buf[32]; string msg; // First 31 bytes of cluster with null memset(buf, 0, 32); strncpy(buf, rc.getCluster().c_str(), 31); msg.assign(buf, 32); msg.append(OriCrypt_Encrypt(myInfo.getBlob(), rc.getKey())); return msg; }
int sys_rwlock_wlock(u32 rw_lock_id, u64 timeout) { sys_rwlock.Log("sys_rwlock_wlock(rw_lock_id=%d, timeout=%lld)", rw_lock_id, timeout); RWLock* rw; if (!sys_rwlock.CheckId(rw_lock_id, rw)) return CELL_ESRCH; const u32 tid = GetCurrentPPUThread().GetId(); if (!rw->wlock_check(tid)) return CELL_EDEADLK; if (rw->wlock_trylock(tid, true)) return CELL_OK; u32 counter = 0; const u32 max_counter = timeout ? (timeout / 1000) : 20000; do { if (Emu.IsStopped()) { ConLog.Warning("sys_rwlock_wlock(rw_lock_id=%d, ...) aborted", rw_lock_id); return CELL_ETIMEDOUT; } Sleep(1); if (rw->wlock_trylock(tid, true)) return CELL_OK; if (counter++ > max_counter) { if (!timeout) { counter = 0; } else { return CELL_ETIMEDOUT; } } } while (true); }
s32 sys_rwlock_wlock(u32 rw_lock_id, u64 timeout) { sys_rwlock.Log("sys_rwlock_wlock(rw_lock_id=%d, timeout=%lld)", rw_lock_id, timeout); RWLock* rw; if (!sys_rwlock.CheckId(rw_lock_id, rw)) return CELL_ESRCH; const u32 tid = GetCurrentPPUThread().GetId(); if (!rw->wlock_check(tid)) return CELL_EDEADLK; if (rw->wlock_trylock(tid, true)) return CELL_OK; u32 counter = 0; const u32 max_counter = timeout ? (timeout / 1000) : 20000; do { if (Emu.IsStopped()) { LOG_WARNING(HLE, "sys_rwlock_wlock(rw_lock_id=%d, ...) aborted", rw_lock_id); return CELL_ETIMEDOUT; } std::this_thread::sleep_for(std::chrono::milliseconds(1)); if (rw->wlock_trylock(tid, true)) return CELL_OK; if (counter++ > max_counter) { if (!timeout) { counter = 0; } else { return CELL_ETIMEDOUT; } } } while (true); }
void* escritor(void * arg){ //++++++++++++++++++++++++++++BARRERA pthread_mutex_lock(&mut); while(!todos_creados){ pthread_cond_wait(&barrera, &mut); } pthread_mutex_unlock(&mut); //++++++++++++++++++++++++++++ lock_valor.wlock(); int yo = (int)(long)arg; printf("mi tid---->%d Cambio valor\n", yo); valor++; nanosleep(&timW, NULL); lock_valor.wunlock(); pthread_exit(NULL); return NULL; }