* hinfo.cc (hinfo::find_unused_handle): Just check for table entry == NULL

since we are already bounds checked by default.
* thread.cc (ResourceLocks::Lock): Streamline this function since it is called
a lot.
(ReleaseResourceLock): Ditto.

diff --git a/winsup/cygwin/ChangeLog b/winsup/cygwin/ChangeLog
index 505d9dd..53fd399 100644 (file)
--- a/winsup/cygwin/ChangeLog
+++ b/winsup/cygwin/ChangeLog
@@ -1,3 +1,11 @@
+Fri Aug  4 00:00:46 2000  Christopher Faylor <cgf@cygnus.com>
+
+       * hinfo.cc (hinfo::find_unused_handle): Just check for table entry ==
+       NULL since we are already bounds checked by default.
+       * thread.cc (ResourceLocks::Lock): Streamline this function since it is
+       called a lot.
+       (ReleaseResourceLock): Ditto.
+
 Thu Aug  3 20:44:39 2000  Christopher Faylor <cgf@cygnus.com>
 
        * select.cc (fhandler_console::select_read): Call set_cursor_maybe

diff --git a/winsup/cygwin/dtable.cc b/winsup/cygwin/dtable.cc
index ad6ec5d..72ee96f 100644 (file)
--- a/winsup/cygwin/dtable.cc
+++ b/winsup/cygwin/dtable.cc
@@ -125,12 +125,13 @@ hinfo::not_open (int fd)
 int
 hinfo::find_unused_handle (int start)
 {
-  AssertResourceOwner(LOCK_FD_LIST,READ_LOCK);
+  AssertResourceOwner(LOCK_FD_LIST, READ_LOCK);
 
   do
     {
       for (int i = start; i < (int) size; i++)
-       if (not_open (i))
+       /* See if open -- no need for overhead of not_open */
+       if (fds[i] == NULL)
          return i;
     }
   while (extend (NOFILE_INCR));

diff --git a/winsup/cygwin/syscalls.cc b/winsup/cygwin/syscalls.cc
index ed20df4..5698a9b 100644 (file)
--- a/winsup/cygwin/syscalls.cc
+++ b/winsup/cygwin/syscalls.cc
@@ -391,7 +391,7 @@ _open (const char *unix_path, int flags, ...)
   syscall_printf ("open (%s, %p)", unix_path, flags);
   if (!check_null_empty_path_errno(unix_path))
     {
-      SetResourceLock(LOCK_FD_LIST,WRITE_LOCK|READ_LOCK," open ");
+      SetResourceLock(LOCK_FD_LIST, WRITE_LOCK|READ_LOCK, " open ");
 
       /* check for optional mode argument */
       va_start (ap, flags);

diff --git a/winsup/cygwin/thread.cc b/winsup/cygwin/thread.cc
index c08ea85..2335d60 100644 (file)
--- a/winsup/cygwin/thread.cc
+++ b/winsup/cygwin/thread.cc
@@ -26,38 +26,41 @@ extern int threadsafe;
 
 #define MT_INTERFACE user_data->threadinterface
 
-#define NOT_IMP(n)  system_printf("not implemented %s\n",n); return 0;
-
-#define CHECKHANDLE(rval,release) \
-  if ( ! item->HandleOke() ) { \
-    if ( release ) item->used=false; \
-    return rval; };
+#define NOT_IMP(n)  system_printf ("not implemented %s\n", n); return 0;
+
+#define CHECKHANDLE(rval, release) \
+  if (!item->HandleOke ()) \
+    { \
+      if (release) \
+       item->used=false; \
+      return rval; \
+    }
 
 #define GETTHREAD(n) \
-  if ( ! thread ) system_printf("thread is NULL");\
-  SetResourceLock(LOCK_THREAD_LIST,READ_LOCK,n);\
-  ThreadItem *item=user_data->threadinterface->GetThread(thread); \
-  ReleaseResourceLock(LOCK_THREAD_LIST,READ_LOCK,n); \
-  if ( ! item ) return EINVAL; \
-  CHECKHANDLE(EINVAL,0);
+  if (!thread) system_printf ("thread is NULL");\
+  SetResourceLock (LOCK_THREAD_LIST, READ_LOCK, n);\
+  ThreadItem *item=user_data->threadinterface->GetThread (thread); \
+  ReleaseResourceLock (LOCK_THREAD_LIST, READ_LOCK, n); \
+  if (!item) return EINVAL; \
+  CHECKHANDLE (EINVAL, 0);
 
 #define GETMUTEX(n) \
-  SetResourceLock(LOCK_MUTEX_LIST,READ_LOCK,n); \
-  MutexItem* item=user_data->threadinterface->GetMutex(mutex); \
-  ReleaseResourceLock(LOCK_MUTEX_LIST,READ_LOCK,n); \
-  if ( ! item ) return EINVAL;  \
-  CHECKHANDLE(EINVAL,0);
+  SetResourceLock (LOCK_MUTEX_LIST, READ_LOCK, n); \
+  MutexItem* item=user_data->threadinterface->GetMutex (mutex); \
+  ReleaseResourceLock (LOCK_MUTEX_LIST, READ_LOCK, n); \
+  if (!item) return EINVAL;  \
+  CHECKHANDLE (EINVAL, 0);
 
 #define GETSEMA(n) \
-  SetResourceLock(LOCK_SEM_LIST,READ_LOCK,n); \
-  SemaphoreItem* item=user_data->threadinterface->GetSemaphore(sem); \
-  ReleaseResourceLock(LOCK_SEM_LIST,READ_LOCK,n); \
-  if ( ! item ) return EINVAL; \
-  CHECKHANDLE(EINVAL,0);
-
-#define CHECKITEM(rn,rm,fn) \
-  if ( ! item ) { \
-    ReleaseResourceLock(rn,rm,fn); \
+  SetResourceLock (LOCK_SEM_LIST, READ_LOCK, n); \
+  SemaphoreItem* item=user_data->threadinterface->GetSemaphore (sem); \
+  ReleaseResourceLock (LOCK_SEM_LIST, READ_LOCK, n); \
+  if (!item) return EINVAL; \
+  CHECKHANDLE (EINVAL, 0);
+
+#define CHECKITEM(rn, rm, fn) \
+  if (!item) { \
+    ReleaseResourceLock (rn, rm, fn); \
     return EINVAL;  }; \
 
 struct _reent *
@@ -68,9 +71,7 @@ _reent_clib ()
 
 #ifdef _CYG_THREAD_FAILSAFE
   if (_r == 0)
-    {
-      system_printf ("local thread storage not inited");
-    }
+    system_printf ("local thread storage not inited");
 #endif
 
   SetLastError (tmp);
@@ -85,22 +86,32 @@ _reent_winsup ()
   _r = (struct __reent_t *) TlsGetValue (MT_INTERFACE->reent_index);
 #ifdef _CYG_THREAD_FAILSAFE
   if (_r == 0)
-    {
-      system_printf ("local thread storage not inited");
-    }
+    system_printf ("local thread storage not inited");
 #endif
   SetLastError (tmp);
   return _r->_winsup;
 };
 
+inline LPCRITICAL_SECTION
+ResourceLocks::Lock (int _resid)
+{
+#ifdef _CYG_THREAD_FAILSAFE
+  if (!inited)
+    system_printf ("lock called before initialization");
+
+  thread_printf ("Get Resource lock %d ==> %p for %p , real : %d , threadid %d ",
+                _resid, &lock, user_data, myself->pid, GetCurrentThreadId ());
+#endif
+  return &lock;
+};
+
 void
 SetResourceLock (int _res_id, int _mode, const char *_function)
 {
-#if 0
-  if (!threadsafe)
-    return;
+#ifdef _CYG_THREAD_FAILSAFE
+  thread_printf ("Set resource lock %d mode %d for %s start",
+                _res_id, _mode, _function);
 #endif
-  thread_printf ("Set resource lock %d mode %d for %s start", _res_id, _mode, _function);
   EnterCriticalSection (user_data->resourcelocks->Lock (_res_id));
 
 #ifdef _CYG_THREAD_FAILSAFE
@@ -112,13 +123,9 @@ SetResourceLock (int _res_id, int _mode, const char *_function)
 void
 ReleaseResourceLock (int _res_id, int _mode, const char *_function)
 {
-#if 0
-  if (!threadsafe)
-    return;
-#endif
+#ifdef _CYG_THREAD_FAILSAFE
   thread_printf ("Release resource lock %d mode %d for %s done", _res_id, _mode, _function);
 
-#ifdef _CYG_THREAD_FAILSAFE
   AssertResourceOwner (_res_id, _mode);
   user_data->resourcelocks->count--;
   if (user_data->resourcelocks->count == 0)
@@ -133,27 +140,15 @@ void
 AssertResourceOwner (int _res_id, int _mode)
 {
 
-  thread_printf ("Assert Resource lock %d ==> for %p , real : %d , threadid %d count %d owner %d", _res_id, user_data, (myself ? myself->pid : -1), GetCurrentThreadId (), user_data->resourcelocks->count, user_data->resourcelocks->owner);
+  thread_printf ("Assert Resource lock %d ==> for %p , real : %d , threadid %d count %d owner %d",
+                _res_id, user_data, myself->pid, GetCurrentThreadId (),
+                user_data->resourcelocks->count, user_data->resourcelocks->owner);
   if (user_data && (user_data->resourcelocks->owner != GetCurrentThreadId ()))
-    {
-      system_printf ("assertion failed, not the resource owner");
-    };
+    system_printf ("assertion failed, not the resource owner");
 }
 
 #endif
 
-LPCRITICAL_SECTION
-ResourceLocks::Lock (int _resid)
-{
-  if (!inited)
-    {
-      system_printf ("lock called before initialization");
-    };
-
-  thread_printf ("Get Resource lock %d ==> %p for %p , real : %d , threadid %d ", _resid, &lock, user_data, (myself ? myself->pid : -1), GetCurrentThreadId ());
-  return &lock;
-};
-
 void
 ResourceLocks::Init ()
 {
@@ -167,7 +162,7 @@ ResourceLocks::Init ()
   count = 0;
 #endif
 
-  thread_printf ("Resource lock %p inited by %p , %d", &lock, user_data, (myself ? myself->pid : -1));
+  thread_printf ("Resource lock %p inited by %p , %d", &lock, user_data, myself->pid);
 };
 
 void
@@ -178,7 +173,7 @@ ResourceLocks::Delete ()
       thread_printf ("Close Resource Locks %p ", &lock);
       DeleteCriticalSection (&lock);
       inited = false;
-    };
+    }
 };
 
 
@@ -200,7 +195,7 @@ MTinterface::Find (void *_value, int (*comp) (void *, void *), register int &_in
       if (current->used && comp (current, _value))
         break;
       current = NULL;
-    };
+    }
   return current;
 };
 
@@ -214,7 +209,7 @@ MTinterface::Find (MTitem & _item, MTList * _list)
       current = _list->items[_index];
       if (current->used && current == &_item)
         break;
-    };
+    }
   return (_index == _list->index ? -1 : _index);
 };
 
@@ -243,13 +238,13 @@ MTinterface::SetItem (int _index, MTitem * _item, MTList * _list)
 int
 CmpPthreadObj (void *_i, void *_value)
 {
-  return ((MTitem *) _i)->Id () == *(int *) _value;
+  return ( (MTitem *) _i)->Id () == * (int *) _value;
 };
 
 int
 CmpThreadId (void *_i, void *_id)
 {
-  return ((ThreadItem *) _i)->thread_id == *(DWORD *) _id;
+  return ( (ThreadItem *) _i)->thread_id == * (DWORD *) _id;
 };
 
 void
@@ -260,7 +255,7 @@ MTinterface::Init0 ()
       threadlist.items[i] = NULL;
       mutexlist.items[i] = NULL;
       semalist.items[i] = NULL;
-    };
+    }
 
   threadlist.index = 0;
   mutexlist.index = 0;
@@ -541,9 +536,7 @@ __pthread_create (pthread_t * thread, const pthread_attr_t * attr, TFD (start_ro
     {
       __pthread_attr_init (&a);
       item = MT_INTERFACE->CreateThread (thread, start_routine, arg, a);
-    };
-
-
+    }
 
   CHECKITEM (LOCK_THREAD_LIST, WRITE_LOCK | READ_LOCK, "__pthread_create")
 
@@ -581,16 +574,16 @@ __pthread_attr_destroy (pthread_attr_t * /*attr*/)
 int
 __pthread_exit (void *value_ptr)
 {
-  ThreadItem *item = MT_INTERFACE->GetCallingThread();
+  ThreadItem *item = MT_INTERFACE->GetCallingThread ();
   item->return_ptr = value_ptr;
-  ExitThread(0);
+  ExitThread (0);
   return 0;
 }
 
 int
-__pthread_join(pthread_t * thread, void **return_val)
+__pthread_join (pthread_t * thread, void **return_val)
 {
-  ThreadItem *item=user_data->threadinterface->GetThread(thread);
+  ThreadItem *item=user_data->threadinterface->GetThread (thread);
 
 
   if (!item)
@@ -605,7 +598,7 @@ __pthread_join(pthread_t * thread, void **return_val)
   else
   {
      item->joinable = 'N';
-     WaitForSingleObject((HANDLE)*thread, INFINITE);
+     WaitForSingleObject ((HANDLE)*thread, INFINITE);
      if (return_val)
         *return_val = item->return_ptr;
   }/* End if*/
@@ -614,9 +607,9 @@ __pthread_join(pthread_t * thread, void **return_val)
 };
 
 int
-__pthread_detach(pthread_t * thread)
+__pthread_detach (pthread_t * thread)
 {
-  ThreadItem *item=user_data->threadinterface->GetThread(thread);
+  ThreadItem *item=user_data->threadinterface->GetThread (thread);
   if (!item)
      return ESRCH;
 
@@ -631,16 +624,16 @@ __pthread_detach(pthread_t * thread)
 }
 
 int
-__pthread_suspend(pthread_t * thread)
+__pthread_suspend (pthread_t * thread)
 {
-  ThreadItem *item=user_data->threadinterface->GetThread(thread);
+  ThreadItem *item=user_data->threadinterface->GetThread (thread);
   if (!item)
      return ESRCH;
 
   if (item->suspended == false)
   {
      item->suspended = true;
-     SuspendThread( (HANDLE)*thread);
+     SuspendThread ((HANDLE)*thread);
   }
 
   return 0;
@@ -648,14 +641,14 @@ __pthread_suspend(pthread_t * thread)
 
 
 int
-__pthread_continue(pthread_t * thread)
+__pthread_continue (pthread_t * thread)
 {
-  ThreadItem *item=user_data->threadinterface->GetThread(thread);
+  ThreadItem *item=user_data->threadinterface->GetThread (thread);
   if (!item)
      return ESRCH;
 
   if (item->suspended == true)
-        ResumeThread( (HANDLE)*thread);
+        ResumeThread ((HANDLE)*thread);
   item->suspended = false;
 
   return 0;
@@ -885,33 +878,33 @@ extern "C"
   int __pthread_create (pthread_t *, const pthread_attr_t *, TFD (start_routine), void *arg)
   {
     return -1;
-  };
+  }
   int __pthread_attr_init (pthread_attr_t * attr)
   {
     return -1;
-  };
+  }
   int __pthread_attr_destroy (pthread_attr_t * attr)
   {
     return -1;
-  };
+  }
   int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size)
   {
     return -1;
-  };
+  }
   int __pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size)
   {
     return -1;
-  };
+  }
 /*
-   __pthread_attr_setstackaddr(...){ return -1; };
-   __pthread_attr_getstackaddr(...){ return -1; };
+   __pthread_attr_setstackaddr (...){ return -1; };
+   __pthread_attr_getstackaddr (...){ return -1; };
  */
   int __pthread_exit (void *value_ptr)
   {
     return -1;
-  };
+  }
 
-  int __pthread_join(pthread_t thread_id, void **return_val)
+  int __pthread_join (pthread_t thread_id, void **return_val)
   {
      return -1;
   }
@@ -919,83 +912,83 @@ extern "C"
   unsigned long __pthread_getsequence_np (pthread_t * thread)
   {
     return 0;
-  };
+  }
   int __pthread_key_create (pthread_key_t * key)
   {
     return -1;
-  };
+  }
   int __pthread_key_delete (pthread_key_t * key)
   {
     return -1;
-  };
+  }
   int __pthread_setspecific (pthread_key_t * key, const void *value)
   {
     return -1;
-  };
+  }
   void *__pthread_getspecific (pthread_key_t * key)
   {
     return NULL;
-  };
+  }
   int __pthread_kill (pthread_t * thread, int sig)
   {
     return -1;
-  };
+  }
   int __pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set)
   {
     return -1;
-  };
+  }
   pthread_t __pthread_self ()
   {
     return -1;
-  };
+  }
   int __pthread_equal (pthread_t * t1, pthread_t * t2)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_lock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_trylock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_unlock (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __pthread_mutex_destroy (pthread_mutex_t *)
   {
     return -1;
-  };
+  }
   int __sem_init (sem_t * sem, int pshared, unsigned int value)
   {
     return -1;
-  };
+  }
   int __sem_destroy (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_wait (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_trywait (sem_t * sem)
   {
     return -1;
-  };
+  }
   int __sem_post (sem_t * sem)
   {
     return -1;
-  };
+  }
   struct _reent *_reent_clib ()
   {
     return NULL;
-  };
+  }
 }
 
 #endif                          // MT_SAFE