Description

   When threads are not present, this routine has no effect.

   This routine notifies the thread scheduler that the current
   thread is willing to release its processor to other threads of
   equivalent or greater scheduling precedence. (A thread generally
   will release its processor to a thread of a greater scheduling
   precedence without calling this routine.) If no other threads of
   equivalent or greater scheduling precedence are ready to execute,
   the thread continues.

   This routine can allow knowledge of the details of an application
   to be used to improve its performance. If a thread does not call
   tis_yield(), other threads may be given the opportunity to run
   at arbitrary points (possibly even when the interrupted thread
   holds a required resource). By making strategic calls to tis_
   yield(), other threads can be given the opportunity to run when
   the resources are free. This improves performance by reducing
   contention for the resource.

   As a general guideline, consider calling this routine after a
   thread has released a resource (such as a mutex) which is heavily
   contended for by other threads. This can be especially important
   if the program is running on a uniprocessor machine, or if the
   thread acquires and releases the resource inside a tight loop.

   Use this routine carefully and sparingly, because misuse can
   cause unnecessary context switching that will increase overhead
   and actually degrade performance. For example, it is counter-
   productive for a thread to yield while it holds a resource that
   the threads to which it is yielding will need. Likewise, it is
   pointless to yield unless there is likely to be another thread
   that is ready to run.