/*
 * This posix timer test program is GPL Licensed
 * copyright (C) 2007 Wind River System Inc.
 *
 * Compile: gcc -o posix_timer_test posix_timer_test.c -lrt -lpthread -static
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/stat.h>
#include <sys/shm.h>
#include <sys/resource.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <time.h>
#include <netinet/in.h>
#include <signal.h>
#include <sys/ipc.h>

void ocm_hrtm_handler(sigval_t arg)
{
	return;	
}

void tp_sleep()
{
    struct timespec treq;
    struct timespec rem;
    treq.tv_sec = 2;
    treq.tv_nsec =0;
    memset(&rem,0x00,sizeof(rem));

    
    while(1){
	nanosleep(&treq, &rem);
		break;
    }
}

void tp_timer(void *para)
{
	unsigned ret;
	timer_t                 timerId, timerId2;
	struct itimerspec       itval;
	struct sigevent         evp;
	unsigned int time = 1000, i;

	memset(&evp, 0, sizeof(evp));
	evp.sigev_notify = (int)SIGEV_THREAD;
	evp.sigev_notify_function = (void *)ocm_hrtm_handler;
	evp.sigev_signo = SIGRTMIN;/* D.C */
	evp.sigev_notify_attributes = NULL;
	evp.sigev_value.sival_int = 0; 

	while(1) {
		ret = timer_create(CLOCK_REALTIME,&evp,&timerId);
		if(ret == -1){
	        	perror("timer_create");
			printf("create error %d\n ", timerId);
		}
		else
    			printf("create ok %d\n ", timerId);
		
		time = 1000;
	    	memset(&itval,0,sizeof(itval));
    		itval.it_value.tv_sec  = time / 1000;           
    		itval.it_value.tv_nsec = (time % 1000)*1000000; 
        	itval.it_interval.tv_sec  = itval.it_value.tv_sec;
        	itval.it_interval.tv_nsec = itval.it_value.tv_nsec;

		ret = timer_settime(timerId,0,&itval,NULL);
		if (ret == -1) 
			perror("timer_settime");

		tp_sleep();
		ret = timer_delete( timerId );
	
		if(ret == -1){
	        	perror("timer_delete");
			printf("delete error %d\n ", timerId);
		}
		else
    			printf("delete ok %d\n ", timerId);
	}
}

int main()
{

	unsigned int i, thnum, para, ret;
	pthread_attr_t      thread_attr;
	pthread_t           thread_id;
	struct sched_param  sched_param;

	printf("enter Create Threads num (Dec)---->");
	scanf("%d",&thnum);


	for(i = 0; i<thnum; i++){
			ret = pthread_attr_init( &thread_attr );
			if(ret !=0){ perror("pthread_attr_init");}

			ret = pthread_attr_setdetachstate( &thread_attr,PTHREAD_CREATE_DETACHED );
			if(ret !=0){ perror("pthread_attr_setdetachstate");}

			ret = pthread_attr_setstacksize( &thread_attr,0x300000);
			if(ret !=0){ perror("pthread_attr_setstacksize");}
			
			ret = pthread_attr_setinheritsched( &thread_attr,PTHREAD_EXPLICIT_SCHED );
			if(ret !=0){ perror("pthread_attr_getinheritsched");}

			ret = pthread_attr_setschedpolicy( &thread_attr,SCHED_FIFO);
			if(ret !=0){ perror("pthread_attr_setschedpolicy");}

			sched_param.__sched_priority = 80;
			ret = pthread_attr_setschedparam( &thread_attr,&sched_param);
			if(ret !=0){ perror("pthread_attr_setschedparam");}

			para = i;
			ret = pthread_create( &thread_id, &thread_attr, (void *)tp_timer, (void*)para );
			if( ret != 0 ){
				printf("pthread_create  NG!! [%d]\n",i);
			}
	}
	while(1) {
		sleep(100);
	}
	return ret;

}