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)) {
|