Пример #1
0
 static void addTempFile(std::string const & filename)
 {
     lock.lock();
     setupUnlocked();
     tmpfilenames.push_back(filename);
     lock.unlock();
 }
Пример #2
0
			void write(iterator sa, iterator se)
			{
				lock.lock();

				// wait for free context if all buffers are in use
				if ( high-low == numbuffers )
				{
					aiocb *waitlist[1] = { &contexts[low%numbuffers] };
					aio_suspend (waitlist,1,0);
					low++;
				}
				
				uint64_t const len = se-sa;

				buffers[high % numbuffers] = ::libmaus::autoarray::AutoArray<char>(len);
				std::copy ( sa, se, buffers[high%numbuffers].get() );
				memset ( &contexts[high%numbuffers], 0, sizeof(aiocb) );
				contexts[high%numbuffers].aio_fildes = fd;
				contexts[high%numbuffers].aio_buf = buffers[high % numbuffers].get();
				contexts[high%numbuffers].aio_nbytes = len;
				contexts[high%numbuffers].aio_offset = 0;
				contexts[high%numbuffers].aio_sigevent.sigev_notify = SIGEV_NONE;
				aio_write( & contexts[high%numbuffers] );		

				high++;		
				
				lock.unlock();
			}
Пример #3
0
			static uint64_t addPipeHandler(SignalHandler * handler)
			{
				lock.lock();
				uint64_t const id = sigpipehandlers.size() ?  (sigpipehandlers.rbegin()->first+1) : 0;
				sigpipehandlers[id] = handler;
				lock.unlock();
				return id;
			}
Пример #4
0
			void write(iterator sa, iterator se)
			{
				lock.lock();
				::libmaus::autoarray::AutoArray<char> buf(se-sa);
				std::copy(sa,se,buf.get());
				ostr.write(buf.get(),se-sa);
				lock.unlock();
			}
Пример #5
0
			static void removeAllHandler(uint64_t const id)
			{
				lock.lock();
				siginthandlers.erase(siginthandlers.find(id));
				sigtermhandlers.erase(sigtermhandlers.find(id));
				sighuphandlers.erase(sighuphandlers.find(id));
				sigpipehandlers.erase(sigpipehandlers.find(id));
				lock.unlock();
			}
Пример #6
0
			static void setup()
			{
				lock.lock();
				if ( ! setupComplete )
				{
					setupTempFileRemovalRoutines();
					setupComplete = true;
				}
				lock.unlock();
			}
Пример #7
0
			static uint64_t addAllHandler(SignalHandler * handler)
			{
				lock.lock();
				uint64_t const pipeid = sigpipehandlers.size() ?  (sigpipehandlers.rbegin()->first+1) : 0;
				uint64_t const hupid = sighuphandlers.size() ?  (sighuphandlers.rbegin()->first+1) : 0;
				uint64_t const termid = sigtermhandlers.size() ?  (sigtermhandlers.rbegin()->first+1) : 0;
				uint64_t const intid = siginthandlers.size() ?  (siginthandlers.rbegin()->first+1) : 0;
				uint64_t const allid = std::max(std::max(pipeid,hupid),std::max(termid,intid));

				siginthandlers[allid] = handler;
				sigtermhandlers[allid] = handler;
				sighuphandlers[allid] = handler;
				sigpipehandlers[allid] = handler;
				
				lock.unlock();
				
				return allid;
			}
Пример #8
0
			static void removePipeHandler(uint64_t const id)
			{
				lock.lock();
				sigpipehandlers.erase(sigpipehandlers.find(id));
				lock.unlock();
			}
Пример #9
0
			static void removeHupHandler(uint64_t const id)
			{
				lock.lock();
				sighuphandlers.erase(sighuphandlers.find(id));
				lock.unlock();
			}
Пример #10
0
			static void removeTermHandler(uint64_t const id)
			{
				lock.lock();
				sigtermhandlers.erase(sigtermhandlers.find(id));
				lock.unlock();
			}
Пример #11
0
 static void setup()
 {
     lock.lock();
     setupUnlocked();
     lock.unlock();
 }
Пример #12
0
			// insert value and return count after insertion			
			void insert(key_type const v, uint64_t const w)
			{
				uint64_t const p0 = hash(v);
				uint64_t p = p0;
				
				// uint64_t loopcnt = 0;

				do
				{
					// position in use?
					if ( H[p].first != base_type::unused() )
					{
						// value already present
						if ( H[p].first == v )
						{
							H[p].second = w;
							return;
						}
						// in use but by other value (collision)
						else
						{
							p = displace(p,v);
						}
					}
					// position is not currently in use, try to get it
					else
					{
						#if defined(LIBMAUS_HAVE_SYNC_OPS)
						bool const ok = __sync_bool_compare_and_swap ( &(H[p].first), base_type::unused(), v);
						#else
						hlock.lock();
						bool const ok = (H[p].first == base_type::unused());
						if ( ok )
							H[p].first = v;
						hlock.unlock();
						#endif
						
						assert ( H[p].first != base_type::unused() );
						
						// got it
						if ( H[p].first == v )
						{
							// if this inserted the value, then increment fill
							if ( ok )
							{
								#if defined(LIBMAUS_HAVE_SYNC_OPS)
								__sync_fetch_and_add(&fill,1);
								#else
								clock.lock();
								fill++;
								clock.unlock();
								#endif
							}

							H[p].second = w;
							return;
						}
						// someone else snapped position p before we got it
						else
						{			
							p = displace(p,v);
						}
					}
				} while ( p != p0 );
				
				::libmaus::exception::LibMausException se;
				se.getStream() << "SimpleHashMap::insert(): unable to insert, table is full." << std::endl;
				se.finish();
				throw se;
			}
Пример #13
0
			/**
			 * flush output file
			 **/
			void flush()
			{
				lock.lock();
				ostr.flush();
				lock.unlock();
			}