sync__unix_8h-source.html

FastDb是高效的内存数据库系统

00268 <span class="keyword">class </span>dbMutex {
00269     <span class="keywordtype">bool</span> initialized;
00270 
00271    <span class="keyword">public</span>:
00272     dbMutex() {
00273         initialized = <span class="keyword">true</span>;
00274     }
00275 
00276     ~dbMutex() { 
00277         initialized = <span class="keyword">false</span>;
00278     }
00279 
00280     <span class="keywordtype">bool</span> isInitialized() { 
00281         <span class="keywordflow">return</span> initialized;
00282     }
00283 
00284     <span class="keywordtype">void</span> lock() {}
00285     <span class="keywordtype">void</span> unlock() {}
00286 };
00287 
00288 <span class="keyword">class </span>dbThread { 
00289   <span class="keyword">public</span>:
00290     <span class="keyword">typedef</span> void (thread_proc* thread_proc_t)(<span class="keywordtype">void</span>*);
00291     <span class="keywordtype">void</span> create(thread_proc_t f, <span class="keywordtype">void</span>* arg) { f(arg); }
00292     <span class="keywordtype">void</span> join() {}
00293     <span class="keywordtype">void</span> detach() {}
00294     <span class="keyword">enum</span> ThreadPriority { 
00295         THR_PRI_LOW, 
00296         THR_PRI_HIGH
00297     };
00298     <span class="keywordtype">void</span> setPriority(ThreadPriority pri) { }
00299     <span class="keyword">static</span> <span class="keywordtype">int</span> numberOfProcessors() { <span class="keywordflow">return</span> 1; }
00300 };
00301 
00302 <span class="keyword">class </span>dbLocalSemaphore { 
00303     <span class="keywordtype">int</span> count;
00304   <span class="keyword">public</span>:
00305     <span class="keywordtype">void</span> wait(dbMutex&amp;) { 
00306         assert (count &gt; 0);
00307         count -= 1;
00308     }
00309     <span class="keywordtype">void</span> signal(<span class="keywordtype">unsigned</span> inc = 1) {
00310         count += inc;
00311     }
00312     <span class="keywordtype">void</span> open(<span class="keywordtype">unsigned</span> initValue = 0) {
00313         count = initValue;
00314     }
00315     <span class="keywordtype">void</span> close() {}
00316 };
00317 
00318 <span class="keyword">class </span>dbLocalEvent { 
00319     <span class="keywordtype">bool</span> signaled;
00320   <span class="keyword">public</span>:
00321     <span class="keywordtype">void</span> wait(dbMutex&amp;) { 
00322         assert(signaled);
00323     }
00324     <span class="keywordtype">bool</span> wait(dbMutex&amp; mutex, time_t timeout) {
00325         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00326     }
00327     <span class="keywordtype">void</span> signal() {
00328         signaled = <span class="keyword">true</span>;
00329     }
00330     <span class="keywordtype">void</span> reset() {
00331         signaled = <span class="keyword">false</span>;
00332     }
00333     <span class="keywordtype">void</span> open(<span class="keywordtype">bool</span> initValue = <span class="keyword">false</span>) {
00334         signaled = initValue;
00335     }
00336     <span class="keywordtype">void</span> close() {}
00337 };
00338 
00339 <span class="keyword">template</span>&lt;<span class="keyword">class</span> T&gt;
00340 <span class="keyword">class </span>dbThreadContext { 
00341     T* value;
00342   <span class="keyword">public</span>:
00343     T* get() { 
00344         <span class="keywordflow">return</span> value;
00345     }
00346     <span class="keywordtype">void</span> set(T* value) { 
00347         this-&gt;value = value;
00348     }
00349     dbThreadContext() { value = NULL; }
00350 };
00351 
00352 
00353 <span class="keyword">class </span>dbProcessId { 
00354     <span class="keywordtype">int</span>       pid;
00355   <span class="keyword">public</span>:
00356     <span class="keywordtype">bool</span> operator != (dbProcessId <span class="keyword">const</span>&amp; other)<span class="keyword"> const </span>{ 
00357         <span class="keywordflow">return</span> pid != other.pid;
00358     }
00359     
00360     <span class="keywordtype">void</span> clear() { 
00361         pid = 0;
00362     }
00363 
00364     <span class="keyword">static</span> dbProcessId getCurrent() {
00365         dbProcessId curr;
00366         curr.pid = getpid();
00367         <span class="keywordflow">return</span> curr;
00368     }
00369 };
00370 
00371 <span class="preprocessor">#endif // NO_PTHREAD</span>
00372 <span class="preprocessor"></span>
00373 
00374 <span class="preprocessor">#define INFINITE (~0U)</span>
00375 <span class="preprocessor"></span>
00376 
00377 <span class="preprocessor">#ifdef USE_POSIX_SEMAPHORES</span>
00378 <span class="preprocessor"></span><span class="comment">// Initialization Mutex using Posix based semaphores</span>
00379 <span class="keyword">class </span>dbInitializationMutex { 
00380     sem_t* sem;
00381   <span class="keyword">public</span>: 
00382     <span class="keyword">enum</span> initializationStatus { 
00383         InitializationError, 
00384         AlreadyInitialized,
00385         NotYetInitialized
00386     };
00387     initializationStatus initialize(<span class="keywordtype">char</span> <span class="keyword">const</span>* name) { 
00388         initializationStatus status;
00389         <span class="keywordtype">char</span>* tmp = NULL;
00390         <span class="keywordflow">if</span> (*name != <span class="charliteral">'/'</span>) { 
00391             tmp = <span class="keyword">new</span> <span class="keywordtype">char</span>[strlen(name)+2];
00392             strcpy(tmp+1, name);
00393             *tmp = <span class="charliteral">'/'</span>;
00394             name = tmp;
00395         }
00396         <span class="keywordflow">while</span> (<span class="keyword">true</span>) {
00397             sem = sem_open(name, 0);
00398             <span class="keywordflow">if</span> (sem == SEM_FAILED) { 
00399                 <span class="keywordflow">if</span> (errno == ENOENT) {
00400                     sem = sem_open(name, O_CREAT|O_EXCL, 0777, 0);
00401                     <span class="keywordflow">if</span> (sem != SEM_FAILED) { 
00402                         status = NotYetInitialized;
00403                         <span class="keywordflow">break</span>;
00404                     } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (errno != EEXIST) { 
00405                         status = InitializationError;
00406                         <span class="keywordflow">break</span>;
00407                     }
00408                 } <span class="keywordflow">else</span> { 
00409                     status = InitializationError;
00410                     <span class="keywordflow">break</span>;
00411                 }
00412             } <span class="keywordflow">else</span> { 
00413                 status = (sem_wait(sem) == 0 &amp;&amp; sem_post(sem) == 0) 
00414                     ? AlreadyInitialized : InitializationError;
00415                 <span class="keywordflow">break</span>;
00416             }
00417         }
00418         <span class="keyword">delete</span>[] tmp;
00419         <span class="keywordflow">return</span> status;
00420     }
00421 
00422     <span class="keywordtype">void</span> done() { 
00423         sem_post(sem);
00424     }
00425     <span class="keywordtype">bool</span> close() {
00426         sem_close(sem);
00427         <span class="keywordflow">return</span> <span class="keyword">false</span>;
00428     }
00429     <span class="keywordtype">void</span> erase() { 
00430         close();
00431     }
00432 };
00433 
00434 <span class="keyword">class </span>dbSemaphore { 
00435   <span class="keyword">protected</span>:
00436     sem_t* sem;
00437   <span class="keyword">public</span>:
00438     <span class="keywordtype">void</span> wait() { 
00439         <span class="keywordtype">int</span> rc = sem_wait(sem);
00440         assert(rc == 0);
00441     }
00442 
00443     <span class="keywordtype">bool</span> wait(<span class="keywordtype">unsigned</span> msec) { 
00444 <span class="preprocessor">#ifdef POSIX_1003_1d</span>
00445 <span class="preprocessor"></span>        <span class="keyword">struct </span>timespec abs_ts;
00446         <span class="keyword">struct </span>timeval  cur_tv;
00447         clock_gettime(CLOCK_REALTIME, &amp;cur_tv);
00448         abs_ts.tv_sec = cur_tv.tv_sec + (msec + cur_tv.tv_usec / 1000) / 1000000; 
00449         abs_ts.tv_nsec = (msec + cur_tv.tv_usec / 1000) % 1000000 * 1000;
00450         <span class="keywordtype">int</span> rc = sem_timedwait(sem, &amp;abs_ts);
00451         <span class="keywordflow">if</span> (rc &lt; 0) { 
00452             assert(errno == ETIMEDOUT);
00453             <span class="keywordflow">return</span> <span class="keyword">false</span>;
00454         }
00455         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00456 <span class="preprocessor">#else </span>
00457 <span class="preprocessor"></span>        <span class="keywordtype">int</span> rc = sem_wait(sem);
00458         assert(rc == 0);
00459         <span class="keywordflow">return</span> <span class="keyword">true</span>;
00460 <span class="preprocessor">#endif  </span>
00461 <span class="preprocessor"></span>    }
00462 
00463     <span class="keywordtype">void</span> signal(<span class="keywordtype">unsigned</span> inc = 1) {
00464         <span class="keywordflow">while</span> (--inc &gt; 0) { 
00465             sem_post(sem);
00466         }
00467     }
00468     <span class="keywordtype">void</span> reset() { 
00469         <span class="keywordflow">while</span> (sem_trywait(sem) == 0);
00470     }    
00471     <span class="keywordtype">bool</span> open(<span class="keywordtype">char</span> <span class="keyword">const</span>* name, <span class="keywordtype">unsigned</span> initValue = 0) {
00472         <span class="keywordtype">char</span>* tmp = NULL;
00473         <span class="keywordflow">if</span> (*name != <span class="charliteral">'/'</span>) { 
00474             tmp = <span class="keyword">new</span> <span class="keywordtype">char</span>[strlen(name)+2];
00475             strcpy(tmp+1, name);
00476             *tmp = <span class="charliteral">'/'</span>;
00477             name = tmp;
00478         }
00479         sem = sem_open(name, O_CREAT, 0777, initValue);
00480         <span class="keyword">delete</span>[] tmp;
00481         <span class="keywordflow">return</span> sem != NULL; 
00482     }
00483     <span class="keywordtype">void</span> close() {
00484         sem_close(sem);
00485     }
00486     <span class="keywordtype">void</span> erase() { 
00487         close();
00488     }
00489 };
00490 
00491 <span class="keyword">class </span>dbEvent : <span class="keyword">public</span> dbSemaphore { 
00492   <span class="keyword">public</span>:
00493     <span class="keywordtype">void</span> wait() { 
00494         dbSemaphore::wait();
00495         sem_post(sem);
00496     }
00497     <span class="keywordtype">bool</span> wait(<span class="keywordtype">unsigned</span> msec) { 
00498         <span class="keywordflow">if</span> (dbSemaphore::wait(msec)) { 
00499             sem_post(sem);
00500             <span class="keywordflow">return</span> <span class="keyword">true</span>;
00501         }
00502         <span class="keywordflow">return</span> <span class="keyword">false</span>;
00503     }
00504     <span class="keywordtype">void</span> signal() {
00505         <span class="keywordflow">while</span> (sem_trywait(sem) == 0);
00506         sem_post(sem);
00507     }
00508     <span class="keywordtype">void</span> reset() {
00509         <span class="keywordflow">while</span> (sem_trywait(sem) == 0);
00510     }
00511     <span class="keywordtype">bool</span> open(<span class="keywordtype">char</span> <span class="keyword">const</span>* name, <span class="keywordtype">bool</span> signaled = <span class="keyword">false</span>) {
00512         <span class="keywordflow">return</span> dbSemaphore::open(name, (<span class="keywordtype">int</span>)signaled);
00513     }
00514 };
00515 <span class="preprocessor">#else // USE_POSIX_SEMAPHORES</span>
00516 <span class="preprocessor"></span>
00517 <span class="comment">// Define local implemenation of InitializationMutex in sync.cpp</span>
00518 <span class="keyword">class </span>dbInitializationMutex { 
00519     <span class="keywordtype">int</span> semid;
00520   <span class="keyword">public</span>: 
00521     <span class="keyword">enum</span> initializationStatus { 
00522         InitializationError, 
00523         AlreadyInitialized,
00524         NotYetInitialized
00525     };
00526     initializationStatus initialize(<span class="keywordtype">char</span> <span class="keyword">const</span>* name);
00527     <span class="keywordtype">void</span> done(); 
00528     <span class="keywordtype">bool</span> close();
00529     <span class="keywordtype">void</span> erase();
00530 };
00531 
00532 
00533 <span class="keyword">class </span>dbSemaphore { 
00534     <span class="keywordtype">int</span> s;
00535   <span class="keyword">public</span>:
00536     <span class="keywordtype">bool</span> wait(<span class="keywordtype">unsigned</span> msec = INFINITE);
00537     <span class="keywordtype">void</span> signal(<span class="keywordtype">unsigned</span> inc = 1);
00538     <span class="keywordtype">bool</span> open(<span class="keywordtype">char</span> <span class="keyword">const</span>* name, <span class="keywordtype">unsigned</span> initValue = 0);
00539     <span class="keywordtype">void</span> reset();
00540     <span class="keywordtype">void</span> close();