< prev index next >

src/os/bsd/vm/os_bsd.cpp

Print this page




1947   #define SEM_POST(sem)           semaphore_signal(sem)
1948   #define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
1949 #else
1950   #define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
1951   #define SEM_WAIT(sem)           sem_wait(&sem)
1952   #define SEM_POST(sem)           sem_post(&sem)
1953   #define SEM_DESTROY(sem)        sem_destroy(&sem)
1954 #endif
1955 
1956 #ifdef __APPLE__
1957 // OS X doesn't support unamed POSIX semaphores, so the implementation in os_posix.cpp can't be used.
1958 
1959 Semaphore::Semaphore(uint value) : _semaphore(0) {
1960   SEM_INIT(_semaphore, value);
1961 }
1962 
1963 Semaphore::~Semaphore() {
1964   SEM_DESTROY(_semaphore);
1965 }
1966 
1967 void Semaphore::signal() {
1968   SEM_POST(_semaphore);
1969 }
1970 
1971 void Semaphore::signal(uint count) {
1972   for (uint i = 0; i < count; i++) {
1973     signal();
1974   }
1975 }
1976 
1977 void Semaphore::wait() {
1978   while (SEM_WAIT(_semaphore) == KERN_ABORTED) {
1979     // Semaphore was interrupted. Retry.
1980   }
1981 }
1982 
1983 class BsdSemaphore : public Semaphore {
1984  private:
1985   static jlong currenttime() {
1986     struct timeval tv;
1987     gettimeofday(&tv, NULL);
1988     return (tv.tv_sec * NANOSECS_PER_SEC) + (tv.tv_usec * 1000);
1989   }
1990 
1991  public:
1992   BsdSemaphore(uint value = 0) : Semaphore(value) {}
1993 


2009 
2010       jlong current = currenttime();
2011       jlong passedtime = current - starttime;
2012 
2013       if (passedtime >= totalwait) {
2014         waitspec.tv_sec = 0;
2015         waitspec.tv_nsec = 0;
2016       } else {
2017         jlong waittime = totalwait - (current - starttime);
2018         waitspec.tv_sec = waittime / NANOSECS_PER_SEC;
2019         waitspec.tv_nsec = waittime % NANOSECS_PER_SEC;
2020       }
2021 
2022       kr = semaphore_timedwait(_semaphore, waitspec);
2023     }
2024 
2025     return kr == KERN_SUCCESS;
2026   }
2027 };
2028 
2029 #else
2030 
2031 class BsdSemaphore : public os::PosixSemaphore {
2032  public:
2033   BsdSemaphore(uint value = 0) : os::PosixSemaphore(value) {}
2034 
2035   bool BsdSemaphore::timedwait(unsigned int sec, int nsec) {
2036     struct timespec ts;
2037     unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
2038 
2039     return os::PosixSemaphore::timedwait(ts);
2040   }
2041 };

2042 
2043 #endif // __APPLE__
2044 
2045 static os_semaphore_t sig_sem;
2046 static BsdSemaphore sr_semaphore;
2047 
2048 void os::signal_init_pd() {
2049   // Initialize signal structures
2050   ::memset((void*)pending_signals, 0, sizeof(pending_signals));
2051 
2052   // Initialize signal semaphore
2053   ::SEM_INIT(sig_sem, 0);
2054 }
2055 
2056 void os::signal_notify(int sig) {
2057   Atomic::inc(&pending_signals[sig]);
2058   ::SEM_POST(sig_sem);
2059 }
2060 
2061 static int check_pending_signals(bool wait) {
2062   Atomic::store(0, &sigint_count);
2063   for (;;) {
2064     for (int i = 0; i < NSIG + 1; i++) {
2065       jint n = pending_signals[i];
2066       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {




1947   #define SEM_POST(sem)           semaphore_signal(sem)
1948   #define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
1949 #else
1950   #define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
1951   #define SEM_WAIT(sem)           sem_wait(&sem)
1952   #define SEM_POST(sem)           sem_post(&sem)
1953   #define SEM_DESTROY(sem)        sem_destroy(&sem)
1954 #endif
1955 
1956 #ifdef __APPLE__
1957 // OS X doesn't support unamed POSIX semaphores, so the implementation in os_posix.cpp can't be used.
1958 
1959 Semaphore::Semaphore(uint value) : _semaphore(0) {
1960   SEM_INIT(_semaphore, value);
1961 }
1962 
1963 Semaphore::~Semaphore() {
1964   SEM_DESTROY(_semaphore);
1965 }
1966 




1967 void Semaphore::signal(uint count) {
1968   for (uint i = 0; i < count; i++) {
1969     SEM_POST(_semaphore);
1970   }
1971 }
1972 
1973 void Semaphore::wait() {
1974   while (SEM_WAIT(_semaphore) == KERN_ABORTED) {
1975     // Semaphore was interrupted. Retry.
1976   }
1977 }
1978 
1979 class BsdSemaphore : public Semaphore {
1980  private:
1981   static jlong currenttime() {
1982     struct timeval tv;
1983     gettimeofday(&tv, NULL);
1984     return (tv.tv_sec * NANOSECS_PER_SEC) + (tv.tv_usec * 1000);
1985   }
1986 
1987  public:
1988   BsdSemaphore(uint value = 0) : Semaphore(value) {}
1989 


2005 
2006       jlong current = currenttime();
2007       jlong passedtime = current - starttime;
2008 
2009       if (passedtime >= totalwait) {
2010         waitspec.tv_sec = 0;
2011         waitspec.tv_nsec = 0;
2012       } else {
2013         jlong waittime = totalwait - (current - starttime);
2014         waitspec.tv_sec = waittime / NANOSECS_PER_SEC;
2015         waitspec.tv_nsec = waittime % NANOSECS_PER_SEC;
2016       }
2017 
2018       kr = semaphore_timedwait(_semaphore, waitspec);
2019     }
2020 
2021     return kr == KERN_SUCCESS;
2022   }
2023 };
2024 
2025 typedef BsdSemaphore OSSemaphore;
2026 
2027 #else


2028 
2029 struct timespec os::PosixSemaphore::create_timespec(unsigned int sec, int nsec) {
2030   struct timespec ts;
2031   unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
2032 
2033   return ts;
2034 }
2035 
2036 typedef os::PosixSemaphore OSSemaphore;
2037 
2038 #endif // __APPLE__
2039 
2040 static os_semaphore_t sig_sem;
2041 static OSSemaphore sr_semaphore;
2042 
2043 void os::signal_init_pd() {
2044   // Initialize signal structures
2045   ::memset((void*)pending_signals, 0, sizeof(pending_signals));
2046 
2047   // Initialize signal semaphore
2048   ::SEM_INIT(sig_sem, 0);
2049 }
2050 
2051 void os::signal_notify(int sig) {
2052   Atomic::inc(&pending_signals[sig]);
2053   ::SEM_POST(sig_sem);
2054 }
2055 
2056 static int check_pending_signals(bool wait) {
2057   Atomic::store(0, &sigint_count);
2058   for (;;) {
2059     for (int i = 0; i < NSIG + 1; i++) {
2060       jint n = pending_signals[i];
2061       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {


< prev index next >