void cyg_thread_create
(
  cyg_addrword_t     sched_info,  /* scheduling info (priority) */
  cyg_thread_entry_t *entry,      /* thread entry point         */
  cyg_addrword_t     entry_data,  /* entry point argument       */
  char               *name,       /* name of thread             */
  void               *stack_base, /* pointer to stack base      */
  cyg_ucount32       stack_size,  /* size of stack in bytes     */
  cyg_handle_t       *handle,     /* returned thread handle     */
  cyg_thread         *thread      /* space to store thread data */
)

One thing to note is that like Unix, the lower the priority value (i.e. sched_info) the higher the priority. A priority of 0 is the highest possible priority in the system and CYG_THREAD_MIN_PRIORITY is the lowest possible priority. It is a good idea not to run any thread at CYG_THREAD_MIN_PRIORITY since the idle thread runs at that priority.

Priority values depend on the scheduler. Note that if you use the bitmap scheduler, two threads cannot share the same priority.

Note that threads are created in a suspended state. Before the thread will run, you must call cyg_thread_resume.

The entry function prototype is: void cyg_thread_entry(CYG_ADDRWORD data).

void cyg_thread_exit
(
  void
)

This will cause any destructors associated with the thread to be called before the thread exits.

cyg_bool_t cyg_thread_delete
(
  cyg_handle_t thread /* thread to delete */
)

void cyg_thread_suspend
(
  cyg_handle_t thread /* thread to suspend */
)

void cyg_thread_resume
(
  cyg_handle_t thread /* thread to resume from a suspended state */
)

If the thread was exited, this will reinitialize the thread.

(? RBW: Will reinitializing thread cause the thread to reinitialize in a suspended state or a running state ? - need to test )

void cyg_thread_kill
(
  cyg_handle_t thread /* thread to kill */
)

This will cause any destructors associated with the thread to be called before the thread is killed.

void cyg_thread_release
(
  cyg_handle_t thread /* thread to release */
)

void cyg_thread_yield
(
  void
)

cyg_handle_t cyg_thread_self
(
  void
)

cyg_handle_t cyg_thread_idle_thread
(
  void
)

void cyg_thread_set_priority
(
  cyg_handle_t   thread,  /* thread ID    */
  cyg_priority_t priority /* new priority */
)

cyg_priority_t cyg_thread_get_priority
(
  cyg_handle_t thread /* thread ID */
)

cyg_priority_t cyg_thread_get_current_priority
(
  cyg_handle_t thread /* thread ID */
)

void cyg_thread_delay
(
  cyg_tick_count_t delay /* number of ticks to delay */
)

cyg_addrword_t cyg_thread_get_stack_base
(
  cyg_handle_t thread /* thread ID */
)

cyg_uint32 cyg_thread_get_stack_size
(
  cyg_handle_t thread /* thread ID */
)

cyg_uint32 cyg_thread_measure_stack_usage
(
  cyg_handle_t thread /* thread ID */
)

cyg_ucount32 cyg_thread_new_data_index
(
  void
)

void cyg_thread_free_data_index
(
  cyg_ucount32 index /* index to free */
)

CYG_ADDRWORD cyg_thread_get_data
(
  cyg_ucount32 index /* index of per thread data */
)

CYG_ADDRWORD *cyg_thread_get_data_ptr
(
  cyg_ucount32 index /* index of per thread data */
)

void cyg_thread_set_data
(
  cyg_ucount32 index, /* index of per thread data */
  CYG_ADDRWORD data   /* data to write            */
)

cyg_bool_t cyg_thread_add_destructor
(
  cyg_thread_destructor_fn fn,  /* destructor function    */
  cyg_addrword_t           data /* argument to destructor */
)

cyg_bool_t cyg_thread_rem_destructor
(
  cyg_thread_destructor_fn fn,  /* destructor function    */
  cyg_addrword_t           data /* argument to destructor */
)