LXR 6.1/​testsuites/​psxtmtests/​psxtmthreadattr01/​init.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:42

 /*
  *  COPYRIGHT (c) 2018.
  *  Himanshu Sekhar Nayak (GCI 2018)
  *
  *  Permission to use, copy, modify, and/or distribute this software
  *  for any purpose with or without fee is hereby granted.
  *
  *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  *  WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  *  WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
  *  BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES
  *  OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  *  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  *  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <timesys.h>
 #include <rtems/btimer.h>
 #include "test_support.h"
 #include <tmacros.h>
 #include <pthread.h>
 #include <timesys.h>
 #include <sched.h>
 
 #define GUARDSIZE_TEST_VALUE 512
 #define STACKSIZE_TEST_VALUE 1024
 
 const char rtems_test_name[] = "PSXTMTHREADATTR01";
 
 /* forward declarations to avoid warnings */
 static void *POSIX_Init(void *argument);
 
 static pthread_attr_t attr;
 static size_t guardsize = GUARDSIZE_TEST_VALUE;
 static size_t stacksize = STACKSIZE_TEST_VALUE;
 static struct sched_param param;
 static void *stackaddr;
 
 static void benchmark_create_pthread_attr(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_init(&attr);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_init: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setdetachstate(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setdetachstate: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getdetachstate(void)
 {
   benchmark_timer_t end_time;
   int  status;
   int detachstate;
 
   benchmark_timer_initialize();
   status = pthread_attr_getdetachstate(&attr, &detachstate);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( detachstate == PTHREAD_CREATE_DETACHED );
 
   put_time(
     "pthread_attr_getdetachstate: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setguardsize(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setguardsize(&attr, guardsize);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setguardsize: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getguardsize(void)
 {
   benchmark_timer_t end_time;
   int  status;
   size_t tmp_guardsize;
 
   benchmark_timer_initialize();
   status = pthread_attr_getguardsize(&attr, &tmp_guardsize);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( tmp_guardsize == guardsize );
 
   put_time(
     "pthread_attr_getguardsize: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setinheritsched(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setinheritsched: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getinheritsched(void)
 {
   benchmark_timer_t end_time;
   int  status;
   int inheritsched;
 
   benchmark_timer_initialize();
   status = pthread_attr_getinheritsched(&attr, &inheritsched);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( inheritsched == PTHREAD_EXPLICIT_SCHED );
 
   put_time(
     "pthread_attr_getinheritsched: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setschedparam(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   status = pthread_attr_setschedparam(&attr, &param);
   rtems_test_assert( status == 0 );
   param.sched_priority = sched_get_priority_min( SCHED_RR ) + 2;
   benchmark_timer_initialize();
   status = pthread_attr_setschedparam(&attr, &param);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setschedparam: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getschedparam(void)
 {
   benchmark_timer_t end_time;
   int  status;
   struct sched_param tmp_param;
 
   status = pthread_attr_getschedparam(&attr, &tmp_param);
   rtems_test_assert( status == 0 );
   tmp_param.sched_priority = sched_get_priority_min( SCHED_RR ) + 2;
   benchmark_timer_initialize();
   status = pthread_attr_getschedparam(&attr, &tmp_param);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( tmp_param.sched_priority == param.sched_priority );
 
   put_time(
     "pthread_attr_getschedparam: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setschedpolicy(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setschedpolicy(&attr, SCHED_RR);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setschedpolicy: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getschedpolicy(void)
 {
   benchmark_timer_t end_time;
   int  status;
   int policy;
 
   benchmark_timer_initialize();
   status = pthread_attr_getschedpolicy(&attr, &policy);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( policy == SCHED_RR );
 
   put_time(
     "pthread_attr_getschedpolicy: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setscope(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setscope: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getscope(void)
 {
   benchmark_timer_t end_time;
   int  status;
   int scope;
 
   benchmark_timer_initialize();
   status = pthread_attr_getscope(&attr, &scope);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert( scope == PTHREAD_SCOPE_PROCESS );
 
   put_time(
     "pthread_attr_getscope: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_setstack(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_setstack(&attr, stackaddr, stacksize);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_setstack: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_pthread_attr_getstack(void)
 {
   benchmark_timer_t end_time;
   int  status;
   size_t tmp_stacksize;
 
   benchmark_timer_initialize();
   status = pthread_attr_getstack(&attr, &stackaddr, &tmp_stacksize);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
   rtems_test_assert(tmp_stacksize == stacksize);
 
   put_time(
     "pthread_attr_getstack: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void benchmark_destroy_pthread_attr(void)
 {
   benchmark_timer_t end_time;
   int  status;
 
   benchmark_timer_initialize();
   status = pthread_attr_destroy(&attr);
   end_time = benchmark_timer_read();
   rtems_test_assert( status == 0 );
 
   put_time(
     "pthread_attr_destroy: only case",
     end_time,
     1,        /* Only executed once */
     0,
     0
   );
 
 }
 
 static void *POSIX_Init(
   void *argument
 )
 {
   TEST_BEGIN();
 
   benchmark_create_pthread_attr();
   benchmark_pthread_attr_setdetachstate();
   benchmark_pthread_attr_getdetachstate();
   benchmark_pthread_attr_setguardsize();
   benchmark_pthread_attr_getguardsize();
   benchmark_pthread_attr_setinheritsched();
   benchmark_pthread_attr_getinheritsched();
   benchmark_pthread_attr_setschedparam();
   benchmark_pthread_attr_getschedparam();
   benchmark_pthread_attr_setschedpolicy();
   benchmark_pthread_attr_getschedpolicy();
   benchmark_pthread_attr_setscope();
   benchmark_pthread_attr_getscope();
   benchmark_pthread_attr_setstack();
   benchmark_pthread_attr_getstack();
   benchmark_destroy_pthread_attr();
 
   TEST_END();
   rtems_test_exit(0);
 }
 
 /* configuration information */
 
 #define CONFIGURE_APPLICATION_NEEDS_SIMPLE_CONSOLE_DRIVER
 #define CONFIGURE_APPLICATION_NEEDS_TIMER_DRIVER
 
 /* configure an instance of the object created/destroyed */
 
 #define CONFIGURE_MAXIMUM_POSIX_THREADS     1
 #define CONFIGURE_POSIX_INIT_THREAD_TABLE
 
 #define CONFIGURE_INIT
 
 #include <rtems/confdefs.h>
 /* end of file */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team