int main(void) {
led2_init(); // Setup GPIO for led2 (on GPIO0.22)
// Turn on power to TIMER2 and TIMER3
// (TIMER0 and TIMER1 on by default)
LPC_SC->PCONP |= PCTIM2_POWERON | PCTIM3_POWERON;
// Initialise all timers
init_timer( 0, TIMER0_INTERVAL );
init_timer( 1, TIMER1_INTERVAL );
init_timer( 2, TIMER2_INTERVAL );
init_timer( 3, TIMER3_INTERVAL );
// Enable all timers
enable_timer( 0 );
enable_timer( 1 );
enable_timer( 2 );
enable_timer( 3 );
// Enter an infinite loop, just incrementing a counter
volatile static int i = 0 ;
while(1) {
i++ ;
}
return 0 ;
}
static int wake_timer_suspend(struct device *dev)
{
struct wake_timer *tm = dev_get_drvdata(dev);
#ifdef USE_32K_CLK
int val;
#endif
if(!(tm->can_suspend && tm->suspend_ms))
return -EBUSY;
#ifdef USE_32K_CLK
val = readl(__io_address(PRCM_TIMER_WKUP_CLK));
val |= 0x07;//timer_wkup_clken
val |= (0x3<<TIMER_WKUP_CLK_SEL_BIT);
writel(val, __io_address(PRCM_TIMER_WKUP_CLK));
val = readl(__io_address(PRCM_WKUP_IRQ_CTRL));
//val = 0x3ff10300;
val |= (0x1<<TIMER_WKUP_INTER_EN_BIT);
writel(val, __io_address(PRCM_WKUP_IRQ_CTRL));
#endif
enable_irq_wake(tm->irq[0]);
/*enable_irq_wake(tm->irq[1]);*/
enable_timer(tm, tm->suspend_ms*10, 0);
#ifdef MANU_UNLOCK
disable_timer(tm, 1);
#endif
return 0;
}
static void __init clocksource_init()
{
#if 1
disable_timer(1);
putreg32(0, STLR_TIMER_GPTMCFG(1));
// Setup periodic timer with incrementing counter
putreg32(TIMER_GPTMTAMR_TAMR_PERIODIC | TIMER_GPTMTAMR_TACDIR_UP, STLR_TIMER_GPTMTAMR(1));
putreg32(0xFFFFFFFF, STLR_TIMER_GPTMTAILR(1));
// Enable timer
enable_timer(1);
clocksource_calc_mult_shift(&sysclk_clocksource, CLOCK_TICK_RATE, 20);
sysclk_clocksource.mask = CLOCKSOURCE_MASK(32);
//sysclk_clocksource.mult =
// clocksource_khz2mult(CLOCK_TICK_RATE / 1000, sysclk_clocksource.shift);
#else
clocksource_calc_mult_shift(&sysclk_clocksource, 4000000, 20);
sysclk_clocksource.mask = CLOCKSOURCE_MASK(24);
putreg32(0xFFFFFF, STLR_SYSTICK_RELOAD);
putreg32(STLR_SYSTICK_CTRL_ENABLE | STLR_SYSTICK_CTRL_CLK_SRC_PIOSC_DIV_4, STLR_SYSTICK_CTRL);
#endif
clocksource_register(&sysclk_clocksource);
}
void timer_start(int timer_index) {
os_printf("Timer driver loaded\n");
//set_prescale(timer_index,2);
enable_timer(timer_index);
os_printf("control address:%x\n", &(timer_pointers[timer_index]->control));
os_printf("control value:%x\n", timer_pointers[timer_index]->control);
}
/*****************************************************************************
** Main Function main()
*****************************************************************************/
int main (void)
{
DWORD counter = 0;
/************ The main Function is an endless loop ************/
/* The timer routine is tested on the Keil MCB214x board */
FIO2DIR = 0x000000FF; /* P1.16..23 defined as Outputs */
FIO2CLR = 0x000000FF; /* turn off all the LEDs */
init_timer( 0, TIME_INTERVAL );
enable_timer( 0 );
while (1)
{ /* Loop forever */
if ( timer0_counter >= (0x20 * counter) )
{
FIO2SET = 1 << counter;
counter++;
if ( counter > 8 )
{
counter = 0;
timer0_counter = 0;
FIO2CLR = 0x000000FF;
}
}
}
return 0;
}
// This is executed as part of the current running thread
// Activities to be done :
// 1. System time updating.
// 2. Timer object value decrementing and setting the flag
// for time out event processing.
// 3. Set if necessary priority recomputation flag.
// 4. Update the time quantum left and cpu usage for the current thread.
// If necessary call the scheduler function after enablig the timer.
// flags : runrun, kprunrun, priocompute, timeoutflag
void timer_handler (int irq)
{
unsigned long oflags;
/* Update system time value. HZ = 50 */
millesecs += 20;
if (millesecs >= 1000)
{
secs++;
millesecs -= 1000;
priocompute = 1;// Once in every one second recompute
//priorities by applying decay factor.
}
// Without locking only the first timer object is observed.
if (timers != NULL)
{
timers->timer_count -= 20;
if (timers->timer_count <= 0) timeoutflag = 1;
}
// Update current thread cpu usage statistics
rr_cl_tick((struct kthread *)current_thread);
if (current_thread->kt_schedinf.sc_tqleft <= 0 || runrun == 1 || kprunrun == 1)
{
// Start scheduler function
CLI;
enable_timer();
scheduler();
STI;
}
return;
}
/*****************************************************************************
** Main Function main()
*****************************************************************************/
int main (void)
{
uint32_t counter = 0;
SystemInit();
LPC_GPIO2->FIODIR = 0x000000FF; /* P2.0...P2.7 defined as Outputs */
LPC_GPIO2->FIOCLR = 0x000000FF; /* turn off all the LEDs */
init_timer( 0, TIME_INTERVAL ); // 10ms
enable_timer( 0 );
while (1)
{ /* Loop forever */
if ( timer0_counter >= (50 * counter) ) // 0.5s
{
LPC_GPIO2->FIOSET = 1 << counter;
counter++;
if ( counter > 8 )
{
counter = 0;
timer0_counter = 0;
LPC_GPIO2->FIOCLR = 0x000000FF;
}
}
}
}
static void kb_irq(void)
{
char buf[2]={0};
char numbuf[6];/*five digit will be enough for a int*/
int i;
byte scancode=inportb(0x60);
//really ineffective
for(i=0;i<sizeof(Scan_Tab);i++)
{
if(scancode==Scan_Tab[i]) break;
}
if(i<sizeof(Scan_Tab) )
{
kprintf("%c", Disp_Tab[i]);
switch (Disp_Tab[i]) {
case 'X': enable_timer();
break;
case 'R': disable_timer();
break;
case 'S': reset_sys();
}
}
outportb(0x20,0x20);
}
void init_status_led( void )
{
IO1DIR |= LEDE; //set LEDE to be an output.
IO1DIR |= DEBUGPIN;
init_timer( TIMER0, statusSignal[globalStatus].us_period);
reset_timer(0);
enable_timer(0);
}
static int userspace_tramp(void *arg)
{
init_new_thread_signals(0);
enable_timer();
ptrace(PTRACE_TRACEME, 0, 0, 0);
os_stop_process(os_getpid());
return(0);
}
static int timer_set_next_event(unsigned long evt,
struct clock_event_device *clk)
{
if( clk != &sysclk_clockevent )
{
printk(KERN_ERR "%s: unknown clock device %s\n", __func__, clk->name);
return -1;
}
disable_timer(0);
putreg32(evt, STLR_TIMER_GPTMTAILR(0));
enable_timer(0);
return 0;
}
static int wake_timer_resume(struct device *dev)
{
struct wake_timer *tm = dev_get_drvdata(dev);
#ifdef USE_32_CLK
int val;
val = readl(__io_address(PRCM_TIMER_WKUP_CLK));
val &= ~(3<<TIMER_WKUP_CLK_SEL_BIT);
writel(val, __io_address(PRCM_TIMER_WKUP_CLK));
#endif
disable_irq_wake(tm->irq[0]);
/*disable_irq_wake(tm->irq[1]);*/
disable_timer(tm, 0);
#ifdef MANU_UNLOCK
enable_timer(tm, tm->wake_ms, 1);
#endif
return 0;
}
/*****************************************************************************
** Main Function main()
*****************************************************************************/
int main (void)
{
uint32_t i;
/* SystemClockUpdate() updates the SystemFrequency variable */
SystemClockUpdate();
LPC_GPIO2->FIODIR = 0x000000FF; /* P2.0..7 defined as Outputs */
LPC_GPIO2->FIOCLR = 0x000000FF; /* turn off all the LEDs */
for ( i = 0; i < 2; i++ )
{
init_timer( i , TIME_INTERVAL );
enable_timer( i );
}
/* Loop forever */
while (1)
{ /* Loop forever */
if ( (timer0_m0_counter > 0) && (timer0_m0_counter <= BLINK_INTERVAL) )
{
LPC_GPIO2->FIOSET = 1 << 2;
}
if ( (timer0_m0_counter > BLINK_INTERVAL) && (timer0_m0_counter <= (BLINK_INTERVAL * 2)) )
{
LPC_GPIO2->FIOCLR = 1 << 2;
}
else if ( timer0_m0_counter > (BLINK_INTERVAL * 2) )
{
timer0_m0_counter = 0;
}
/* Timer 1 blinky LED 1 */
if ( (timer1_m0_counter > 0) && (timer1_m0_counter <= BLINK_INTERVAL) )
{
LPC_GPIO2->FIOSET = 1 << 3;
}
if ( (timer1_m0_counter > BLINK_INTERVAL) && (timer1_m0_counter <= (BLINK_INTERVAL * 2)) )
{
LPC_GPIO2->FIOCLR = 1 << 3;
}
else if ( timer1_m0_counter > (BLINK_INTERVAL * 2) )
{
timer1_m0_counter = 0;
}
}
}
/**
* @brief
* This function sleeps for given number of seconds
* @param secs
* Number of secs to sleep
*/
void sw_sleep(u32 secs)
{
timeval_t time;
time.tval.nsec = 0;
time.tval.sec = secs;
# ifndef CONFIG_EMULATE_FIQ
int current_context;
struct timer_event *tevent;
current_context = get_current_task_id();
#ifdef TIMER_DBG
sw_printf("SW: sleep sec 0x%08x nsec 0x%08x \n",time.tval.sec,time.tval.nsec);
#endif
tevent = timer_event_create(&wake_up_from_sleep, ¤t_context);
if(!tevent){
sw_printf("SW: Out of memory : Cannot Perform Sleep\n");
return;
}
timer_event_start(tevent, &time);
suspend_task(current_context, TASK_STATE_WAIT);
schedule();
# else
u32 clockcycles = timeval_to_clockcycles(&time);
#ifdef TIMER_DBG
sw_printf("SW: clockcycles 0x%08x \n",clockcycles);
#endif
enable_timer();
while(1){
u32 curr_val = read_sleep_timer();
if(curr_val > clockcycles){
break;
}
}
disable_timer();
# endif
return;
}
static void timer_set_mode(enum clock_event_mode mode,
struct clock_event_device *clk)
{
if( clk != &sysclk_clockevent )
{
printk(KERN_ERR "%s: unknown clock device %s\n", __func__, clk->name);
return;
}
disable_timer(0);
switch(mode) {
case CLOCK_EVT_MODE_PERIODIC:
printk(KERN_DEBUG "%s\n", "\tCLOCK_EVT_MODE_PERIODIC");
// Clear configuration register
putreg32(0, STLR_TIMER_GPTMCFG(0));
// Setup periodic timer with decrimenting counter
putreg32(TIMER_GPTMTAMR_TAMR_PERIODIC, STLR_TIMER_GPTMTAMR(0));
// Set CONFIG_HZ interval
putreg32(CLOCK_TICK_RATE / CONFIG_HZ, STLR_TIMER_GPTMTAILR(0));
// Enable timer interrupt
putreg32(TIMER_GPTMIMR_TATOIM_MASK, STLR_TIMER_GPTMIMR(0));
// Enable timer
enable_timer(0);
break;
case CLOCK_EVT_MODE_ONESHOT:
printk(KERN_DEBUG "%s\n", "\tCLOCK_EVT_MODE_ONESHOT");
putreg32(0, STLR_TIMER_GPTMCFG(0));
// Setup one shot timer with decrimenting counter
putreg32(TIMER_GPTMTAMR_TAMR_ONESHOT, STLR_TIMER_GPTMTAMR(0));
break;
case CLOCK_EVT_MODE_RESUME:
printk(KERN_DEBUG "%s\n", "\tCLOCK_EVT_MODE_RESUME");
break;
case CLOCK_EVT_MODE_UNUSED:
printk(KERN_DEBUG "%s\n", "\tCLOCK_EVT_MODE_UNUSED");
break;
case CLOCK_EVT_MODE_SHUTDOWN:
printk(KERN_DEBUG "%s\n", "\tCLOCK_EVT_MODE_SHUTDOWN");
break;
}
}
void main ( void )
{
init_timer0();
enable_timer(0);
Delay(1000);
LCD_Init();
LCD_Clear();
LCD_DisplayString(1,1,"Welcome To Arya Omnitalk");
SET_PORT1_PIN_DIRN_OUT(1<<24);
LCD_BKLIT_OFF;
while(1)
{
LCD_BKLIT_OFF;
Delay(10);
LCD_BKLIT_ON;
Delay(10);
}
}
/*
*how do we init timer:
* 1.init the timer frequency
* 2.set the timer irq routine.
* 3.enable timer
*/
void init_timer()
{
int max;
vector_t v;
timefly = 0;
/*00,use IRQ timer,00:read 2 bytes,low &high;
011,mode 3(square wave);0,binary mode*/
max=SHED_RREQ; /*set to 10ms */
outportb(0x43,0x36); /*0000110110b=0x36*/
outportb(0x40, max & 0xff);//LSB
outportb( 0x40,max >> 8 );//MSB
enable_timer(); /* timer enable here, no longer use keyboard */
//install the timer handler
//v.eip = (unsigned)timer_irq;
//v.access_byte = 0x8E; /* present, ring 0, '386 interrupt gate D=32bit gate*/
//setvect(&v, 0x20);
}
static void new_thread_handler(int sig)
{
unsigned long disable;
int (*fn)(void *);
void *arg;
fn = current->thread.request.u.thread.proc;
arg = current->thread.request.u.thread.arg;
UPT_SC(¤t->thread.regs.regs) = (void *) (&sig + 1);
disable = (1 << (SIGVTALRM - 1)) | (1 << (SIGALRM - 1)) |
(1 << (SIGIO - 1)) | (1 << (SIGPROF - 1));
SC_SIGMASK(UPT_SC(¤t->thread.regs.regs)) &= ~disable;
suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
force_flush_all();
if(current->thread.prev_sched != NULL)
schedule_tail(current->thread.prev_sched);
current->thread.prev_sched = NULL;
init_new_thread_signals(1);
enable_timer();
free_page(current->thread.temp_stack);
set_cmdline("(kernel thread)");
change_sig(SIGUSR1, 1);
change_sig(SIGVTALRM, 1);
change_sig(SIGPROF, 1);
local_irq_enable();
if(!run_kernel_thread(fn, arg, ¤t->thread.exec_buf))
do_exit(0);
/* XXX No set_user_mode here because a newly execed process will
* immediately segfault on its non-existent IP, coming straight back
* to the signal handler, which will call set_user_mode on its way
* out. This should probably change since it's confusing.
*/
}
void bootstrap (struct td *tds, void (*f)(), int *stacks) {
bwprintf (COM2, "[s[2J[2;1000r[;H[45mThis is a taskbar."
"[K[m[u");
bwprintf(COM2, "[?25l[2;1H");
bwputstr(COM2, "Welcome to\r\n"
"+--------------------------------------------------+\r\n"
"| ______ __ ______ ____ |\r\n"
"| / __/ /________ __ _ / / ___ / / __ \\/ __/ |\r\n"
"| _\\ \\/ __/ __/ _ \\/ ' \\/ _ \\/ _ \\/ / /_/ /\\ \\ |\r\n"
"| /___/\\__/_/ \\___/_/_/_/_.__/\\___/_/\\____/___/ |\r\n"
"| v0.0.3 (Techno Fitness) |\r\n"
"+--------------------------------------------------+\r\n\r\n");
DPRINTFUNC ("bootstrap");
install_handler ();
DPRINTOK ("Interrupt handler installed.\n");
enable_timer ();
enable_interrupts ();
_kCreate(tds, IDLE, f, 0, 0, stacks);
DPRINTOK ("First user task created.\n");
DPRINTOK ("Booting complete.\n");
}
void finish_fork_handler(int sig)
{
UPT_SC(¤t->thread.regs.regs) = (void *) (&sig + 1);
suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
force_flush_all();
if(current->thread.prev_sched != NULL)
schedule_tail(current->thread.prev_sched);
current->thread.prev_sched = NULL;
enable_timer();
change_sig(SIGVTALRM, 1);
local_irq_enable();
if(current->mm != current->parent->mm)
protect_memory(uml_reserved, high_physmem - uml_reserved, 1,
1, 0, 1);
task_protections((unsigned long) current_thread);
free_page(current->thread.temp_stack);
local_irq_disable();
change_sig(SIGUSR1, 0);
set_user_mode(current);
}
void timer_thread(void)
{
char fast_flag=0;
char slow_flag=0;
//char dns_flag=0;
disable_timer();//变量重入
fast_flag=time_flag;
time_flag=0;
slow_flag=slow_timer;
if(dns_time>4){
dns_time=0;
}
enable_timer();
if(fast_flag){//lwip不可重入解决方法
time_flag=0;
tcp_fasttmr();
if(slow_flag)
tcp_slowtmr();
// if(dns_flag)
// dns_tmr();//dns updata
}
}
void flush_thread_tt(void)
{
unsigned long stack;
int new_pid;
stack = alloc_stack(0, 0);
if(stack == 0){
printk(KERN_ERR
"flush_thread : failed to allocate temporary stack\n");
do_exit(SIGKILL);
}
new_pid = start_fork_tramp(task_stack_page(current), stack, 0, exec_tramp);
if(new_pid < 0){
printk(KERN_ERR
"flush_thread : new thread failed, errno = %d\n",
-new_pid);
do_exit(SIGKILL);
}
if(current_thread->cpu == 0)
forward_interrupts(new_pid);
current->thread.request.op = OP_EXEC;
current->thread.request.u.exec.pid = new_pid;
unprotect_stack((unsigned long) current_thread);
os_usr1_process(os_getpid());
change_sig(SIGUSR1, 1);
change_sig(SIGUSR1, 0);
enable_timer();
free_page(stack);
protect_memory(uml_reserved, high_physmem - uml_reserved, 1, 1, 0, 1);
stack_protections((unsigned long) current_thread);
force_flush_all();
unblock_signals();
}
void mcount( unsigned long frompc, unsigned long selfpc )
{
register struct gmonparam *p = NULL;
register long toindex, fromindex;
int j;
disable_timer();
//print("CG: "); putnum(frompc); print("->"); putnum(selfpc); print("\r\n");
// check that frompcindex is a reasonable pc value.
// for example: signal catchers get called from the stack,
// not from text space. too bad.
//
for(j = 0; j < n_gmon_sections; j++ ){
if((frompc >= _gmonparam[j].lowpc) && (frompc < _gmonparam[j].highpc)) {
p = &_gmonparam[j];
break;
}
}
if( j == n_gmon_sections )
goto done;
#ifdef PROFILE_NO_FUNCPTR
fromindex = searchpc( p->cgtable, p->cgtable_size, frompc ) ;
if( fromindex == -1 ) {
fromindex = p->cgtable_size ;
p->cgtable_size++ ;
p->cgtable[fromindex].frompc = frompc ;
p->cgtable[fromindex].selfpc = selfpc ;
p->cgtable[fromindex].count = 1 ;
goto done ;
}
p->cgtable[fromindex].count++ ;
#else
fromindex = searchpc( p->froms, p->fromssize, frompc ) ;
if( fromindex == -1 ) {
fromindex = p->fromssize ;
p->fromssize++ ;
//if( fromindex >= N_FROMS ) {
//print("Error : From PC table overflow\r\n") ;
//goto overflow ;
//}
p->froms[fromindex].frompc = frompc ;
p->froms[fromindex].link = -1 ;
}else {
toindex = p->froms[fromindex].link ;
while(toindex != -1) {
toindex = (p->tossize - toindex)-1 ;
if( p->tos[toindex].selfpc == selfpc ) {
p->tos[toindex].count++ ;
goto done ;
}
toindex = p->tos[toindex].link ;
}
}
//if( toindex == -1 ) {
p->tos-- ;
p->tossize++ ;
//if( toindex >= N_TOS ) {
//print("Error : To PC table overflow\r\n") ;
//goto overflow ;
//}
p->tos[0].selfpc = selfpc ;
p->tos[0].count = 1 ;
p->tos[0].link = p->froms[fromindex].link ;
p->froms[fromindex].link = p->tossize-1 ;
#endif
done:
p->state = GMON_PROF_ON;
goto enable_timer ;
//overflow:
p->state = GMON_PROF_ERROR;
enable_timer:
enable_timer();
return ;
}
/*****************************************************************************
** Main Function main()
*****************************************************************************/
int main (void)
{
/* SystemClockUpdate() updates the SystemFrequency variable */
SystemClockUpdate();
LPC_GPIO2->FIODIR = 0x0000000F; /* P2.0..3 defined as Outputs */
LPC_GPIO2->FIOCLR = 0x0000000F; /* turn off all the LEDs */
/* Do a P2M DMA transfer using timer match out as a trigger */
DMA_Init(P2M);
#if 0
LPC_GPDMACH0->CConfig |= 0x0C001|(TMR0_M0_REQ<<1)|(0x00<<6)|(0x02<<11);
LPC_SC->DMAREQSEL = (0x1<<0);
init_timer( 0, TIME_INTERVAL );
enable_timer( 0 );
#endif
#if 0
LPC_GPDMACH0->CConfig |= 0x0C001|(TMR0_M1_REQ<<1)|(0x00<<6)|(0x02<<11);
LPC_SC->DMAREQSEL = (0x1<<1);
init_timer( 0, TIME_INTERVAL );
enable_timer( 0 );
#endif
#if 1
LPC_GPDMACH0->CConfig |= 0x0C001|(TMR1_M0_REQ<<1)|(0x00<<6)|(0x02<<11);
LPC_SC->DMAREQSEL = (0x1<<2);
init_timer( 1, TIME_INTERVAL );
enable_timer( 1 );
#endif
#if 0
LPC_GPDMACH0->CConfig |= 0x0C001|(TMR1_M1_REQ<<1)|(0x00<<6)|(0x02<<11);
LPC_SC->DMAREQSEL = (0x1<<3);
init_timer( 1, TIME_INTERVAL );
enable_timer( 1 );
#endif
/* When DMADone is set, it indicates that DMA has been triggered
by MAT_OUT(0.0). */
while ( !CH0DMADone );
CH0DMADone = 0;
/* Loop forever */
while (1)
{
/* Timer 0 blinky LED 0 */
if ( (timer0_m0_counter > 0) && (timer0_m0_counter <= BLINK_INTERVAL) )
{
LPC_GPIO2->FIOSET = 1 << 2;
}
if ( (timer0_m0_counter > BLINK_INTERVAL) && (timer0_m0_counter <= (BLINK_INTERVAL * 2)) )
{
LPC_GPIO2->FIOCLR = 1 << 2;
}
else if ( timer0_m0_counter > (BLINK_INTERVAL * 2) )
{
timer0_m0_counter = 0;
}
/* Timer 1 blinky LED 1 */
if ( (timer1_m0_counter > 0) && (timer1_m0_counter <= BLINK_INTERVAL) )
{
LPC_GPIO2->FIOSET = 1 << 3;
}
if ( (timer1_m0_counter > BLINK_INTERVAL) && (timer1_m0_counter <= (BLINK_INTERVAL * 2)) )
{
LPC_GPIO2->FIOCLR = 1 << 3;
}
else if ( timer1_m0_counter > (BLINK_INTERVAL * 2) )
{
timer1_m0_counter = 0;
}
}
}
int
main (int argc, char **argv, char **envp)
{
global_prog_name = argv[0];
if (argc == 1) {
usage(global_prog_name);
exit(1);
}
// Determine which version of OS X we are running on.
int major_version_num;
int minor_version_num;
int subminor_version_num;
get_macosx_version(&major_version_num, &minor_version_num,
&subminor_version_num);
struct poll_state ps;
ps.use_polling = 0;
if (major_version_num >= 10) {
// Mac OS X 10.5.* and earlier return a number that appears
// correct from the ru_maxrss field of getrusage(), also
// filled in by wait4().
// Mac OS X 10.6.* always returns 0 for ru_maxrss, so we must
// use a different method to measure it.
ps.use_polling = 1;
}
char **child_argv = (char **) malloc((unsigned) argc * sizeof(char *));
int i;
for (i = 1; i < argc; i++) {
child_argv[i-1] = argv[i];
}
child_argv[argc-1] = NULL;
// char **p;
// for (p = child_argv; *p != NULL; p++) {
// fprintf(stderr, " p[%d]='%s'", p-child_argv, *p);
// }
// fprintf(stderr, "\n");
struct timeval start_time;
struct timeval end_time;
unsigned int num_cpus = get_num_cpus();
cpu_usage *total_cpu_stats_start = malloc_cpu_stats(1);
cpu_usage *per_cpu_stats_start = malloc_cpu_stats(num_cpus);
cpu_usage *total_cpu_stats_end = malloc_cpu_stats(1);
cpu_usage *per_cpu_stats_end = malloc_cpu_stats(num_cpus);
get_cpu_usage(num_cpus, per_cpu_stats_start, total_cpu_stats_start);
int ret = gettimeofday(&start_time, NULL);
// tbd: check ret
pid_t pid = fork();
if (pid == -1) {
fprintf(stderr, "Error return status -1 while attempting"
" to call fork(). errno=%d\n", errno);
perror(global_prog_name);
exit(3);
} else if (pid == 0) {
// We are the child process
// Set the uid to the original uid of the process that invoked
// the timemem-darwin process, so that the command being
// measured is run with that user's priviliges, not with root
// privileges.
int original_uid = getuid();
int ret = setuid(original_uid);
if (ret != 0) {
fprintf(stderr, "Error return status %d while attempting"
" to set uid to %d. errno=%d\n", ret, original_uid,
errno);
perror(global_prog_name);
exit(4);
}
ret = execvp(child_argv[0], child_argv);
// Normally the call above will not return.
fprintf(stderr, "Error return status %d while attempting"
" to call execvp(). errno=%d\n", ret, errno);
perror(global_prog_name);
exit(2);
}
// We are the parent process.
// We want to wait until the child process finishes, but we also
// want to periodically poll the child process's resident set size
// (memory usage). On OS X 10.5.8 and earlier, simply using
// wait4() for the child to finish would fill in the rusage struct
// with the maximum resident set size, but this value is always
// filled in with 0 in OS X 10.6, hence the use of polling.
// We implement the polling by calling setitimer() so that we are
// sent a SIGALRM signal every 100 msec. This should cause
// wait4() to return early. We handle the signal, and then call
// wait4() again.
// Read the current maximum resident set size once before starting
// the timer, because the most likely reason for it to fail is
// that we are not running with root privileges.
if (ps.use_polling) {
if (init_polling_process_rss(pid, &ps) != 0) {
run_as_superuser_msg(global_prog_name);
exit(1);
}
poll_process_rss(&ps);
// Set up the SIGALRM signal handler.
global_sigalrm_handled = 0;
enable_handling_sigalrm();
// Set timer to send us a SIGALRM signal every 100 msec.
int timer_period_msec = 100;
enable_timer(timer_period_msec);
}
//int wait_opts = WNOHANG;
int wait_opts = 0;
int wait_status;
int wait4_ret;
struct rusage r;
while (1) {
wait4_ret = wait4(pid, &wait_status, wait_opts, &r);
if (wait4_ret != -1) {
break;
}
if ((errno == EINTR) && ps.use_polling) {
// Most likely the SIGALRM timer signal was handled. If
// so, poll the child process's memory use once. The
// timer should automatically signal again periodically
// without having to reset it.
if (global_sigalrm_handled) {
poll_process_rss(&ps);
global_sigalrm_handled = 0;
if (ps.task_info_errored) {
disable_timer();
ignore_sigalrm();
}
}
// Go around and call wait4() again.
} else {
fprintf(stderr, "wait4() returned %d. errno=%d\n",
wait4_ret, errno);
perror(global_prog_name);
exit(5);
}
}
// We may not use end_time if there are errors we haven't checked
// for yet from wait4(), but it is more accurate to call this as
// soon after wait4() returns as we can. It is out of the loop
// above to avoid the overhead of calling it on every poll time.
if (debug) {
fprintf(stderr, "About to call gettimeofday()\n");
}
ret = gettimeofday(&end_time, NULL);
// tbd: check ret
get_cpu_usage(num_cpus, per_cpu_stats_end, total_cpu_stats_end);
if (wait4_ret != pid) {
fprintf(stderr, "wait4() returned pid=%d. Expected pid"
" %d of child process. Try again.\n", wait4_ret, pid);
fprintf(stderr, "wait4 r.ru_maxrss=%ld\n", r.ru_maxrss);
exit(7);
}
ps.wait4_returned_normally = 1;
if (debug) {
fprintf(stderr, "wait4() returned pid=%d of child process."
" Done!\n", pid);
}
if (ps.use_polling) {
// Disable the timer. Ignore SIGALRM, too, just in case one
// more happens.
if (debug) {
fprintf(stderr, "About to disable the timer\n");
}
disable_timer();
if (debug) {
fprintf(stderr, "About to ignore SIGALRM\n");
}
ignore_sigalrm();
}
// Elapsed time
int elapsed_msec = timeval_diff_msec(&start_time, &end_time);
fprintf(stderr, "real %9d.%03d\n", (elapsed_msec / 1000),
(elapsed_msec % 1000));
// User, sys times
fprintf(stderr, "user %9ld.%03d\n", r.ru_utime.tv_sec,
r.ru_utime.tv_usec / 1000);
fprintf(stderr, "sys %9ld.%03d\n", r.ru_stime.tv_sec,
r.ru_stime.tv_usec / 1000);
// Maximum resident set size
if (! ps.use_polling) {
// At least on the Intel Core 2 Duo Mac OS X 10.5.8 machine on
// which I first tested this code, it seemed to give a value
// of up to 2^31-4096 bytes correctly, but if it went a little
// bit over that, the fprintf statement showed it as 0, not
// 2^31 bytes. For now, I'll do a special check for 0 and
// print out what I believe to be the correct value.
// One way to test this on that machine is as follows. The
// first command below prints 2^31-4096 bytes as the maximum
// resident set size. Without the "if" condition below, the
// second command below prints 0 as the maximum resident set
// size.
// ./timemem-darwin ../../memuse/test-memuse 2096863
// ./timemem-darwin ../../memuse/test-memuse 2096864
// Reference:
// http://lists.apple.com/archives/darwin-kernel/2009/Mar/msg00005.html
if (r.ru_maxrss == 0L) {
// Print 2^31 bytes exactly
fprintf(stderr, "2147483648 maximum resident set size from getrusage\n");
} else {
fprintf(stderr, "%10lu maximum resident set size from getrusage\n",
(unsigned long) r.ru_maxrss);
}
}
if (ps.use_polling) {
long delta = (long) ps.max_rss_bytes - (long) r.ru_maxrss;
fprintf(stderr, "%10lu maximum resident set size from polling (%.1f MB, delta %ld bytes = %.1f MB)\n",
(unsigned long) ps.max_rss_bytes,
(double) ps.max_rss_bytes / (1024.0 * 1024.0),
delta,
(double) delta / (1024.0 * 1024.0));
double elapsed_time_sec = (double) elapsed_msec / 1000.0;
fprintf(stderr,
"number of times rss polled=%ld, avg of %.1f times per second\n",
ps.num_polls,
(double) ps.num_polls / elapsed_time_sec);
fprintf(stderr,
"time between consecutive polls (msec): min=%.1f max=%.1f\n",
(double) ps.consecutive_poll_separation_min_msec,
(double) ps.consecutive_poll_separation_max_msec);
int64 max_rss_first_seen_msec =
timeval_diff_msec(&start_time,
&(ps.poll_time_when_maxrss_first_seen));
fprintf(stderr, "Max RSS observed %.1f sec after start time\n",
(double) max_rss_first_seen_msec / 1000.0);
if (ps.task_info_errored) {
int64 diff_msec = timeval_diff_msec(&end_time,
&(ps.task_info_error_time));
if (diff_msec <= 0 && diff_msec >= -100) {
// Then the error most likely occurred because the
// child process had already exited. Ignore it.
} else {
fprintf(stderr, "A call to task_info() returned an error. error_time - end_time = %.3f sec. This may mean the maximum resident set size measurement above is too low.\n",
(double) diff_msec / 1000.0);
}
}
}
// Show separate busy percentage for each CPU core
fprintf(stderr, "Per core CPU utilization (%d cores):", num_cpus);
for (i = 0; i < num_cpus; i++) {
uint64 total = (per_cpu_stats_end[i].total -
per_cpu_stats_start[i].total);
int cpu_busy_percent = 0;
if (total != 0) {
uint64 idle = (per_cpu_stats_end[i].idle -
per_cpu_stats_start[i].idle);
cpu_busy_percent =
(int) round(100.0 * (1.0 - ((float) idle)/total));
}
fprintf(stderr, " %d%%", cpu_busy_percent);
}
fprintf(stderr, "\n");
if (WIFEXITED(wait_status)) {
// Exit with the same status that the child process did.
exit(WEXITSTATUS(wait_status));
} else if (WIFSIGNALED(wait_status)) {
fprintf(stderr,
"Command stopped due to signal %d without calling exit().\n",
WTERMSIG(wait_status));
exit(1);
} else {
fprintf(stderr,
"Command is stopped due to signal %d, and can be restarted.\n",
WSTOPSIG(wait_status));
exit(2);
}
return 0;
}
void* scheduler(void* p)
{
//這裡還要加上signal mask防止interrupt過來
th_queue_t* queueSche;
th_queue_t* nextQueueTh;
// queueSche = th_queue_head(ready_queueHead);
// srand(time(NULL)); //seed rand()
//disable_timer();
pthread_mutex_lock(&output_lock);
pthread_mutex_lock(&output_lock);
printf("I`m in %d, %d\n", getpid(), sched_queueHead==NULL);fflush(stdout);
pthread_mutex_unlock(&output_lock);
for(;;) //infinite loop
{
if((queueSche = find_thread_by_tid(sched_queueHead, getpid())) == NULL)
abort();
pthread_mutex_lock(&kill_lock);
if(wait_for_kill>0)
{
if(getpid() != main_kernel_id)
{
th_queue_delete(sched_queueHead, queueSche->thread);
wait_for_kill--;
pthread_mutex_unlock(&kill_lock);
pthread_mutex_lock(&output_lock);
printf("kill %d, wait = %d\n", getpid(),wait_for_kill );fflush(stdout);
pthread_mutex_unlock(&output_lock);
exit(0);
abort();
}
}
pthread_mutex_unlock(&kill_lock);
pthread_mutex_lock(&findthread_lock);
for(;;)
{
if((nextQueueTh = find_next_thread(ready_queueHead, queueSche->thread->current_tid)) == NULL)
abort();
queueSche->thread->current_tid = nextQueueTh->thread->tid;
if(nextQueueTh->thread->mctx.status == TH_WAITING)
{
break;
}
}
pthread_mutex_lock(&output_lock);
printf("I`m %d find out %d, %dn", getpid(), nextQueueTh->thread->tid, nextQueueTh->thread->mctx.status);fflush(stdout);
pthread_mutex_unlock(&output_lock);
nextQueueTh->thread->mctx.status = TH_RUNNING;
queueSche->thread->current_tid = nextQueueTh->thread->tid;
pthread_mutex_unlock(&findthread_lock);
enable_timer();
mctx_switch(&(queueSche->thread->mctx), &(nextQueueTh->thread->mctx));
if(nextQueueTh->thread->mctx.status !=TH_EXITED && \
nextQueueTh->thread->mctx.status !=TH_KILLED)
nextQueueTh->thread->mctx.status = TH_WAITING;
pthread_mutex_lock(&output_lock);
//printf("I`m %d comeback from %d\n", getpid(), nextQueueTh->thread->tid);fflush(stdout);
pthread_mutex_unlock(&output_lock);
/*
mctx_list[currentTid].status=TH_RUNNING;
mctx_switch(&mctx_list[0],&mctx_list[currentTid]);
*/
}
return NULL;
}
static int __devinit wake_timer_probe(struct platform_device *pdev)
{
struct resource *res = NULL;
struct wake_timer * tm = NULL;
int retval = 0;
struct wake_timer_data * data = pdev->dev.platform_data;
/*
* Dynamically allocate info and par
*/
tm = kmalloc(sizeof(struct wake_timer), GFP_KERNEL);
if (!tm) {
/* goto error path */
retval = -ENOMEM;
goto out;
}
tm->pdev = pdev;
tm->stat = STAT_ON;
tm->count = 0;
tm->can_suspend = (load_n3s3_fw(pdev) == 0? 1:0);
if(data) {
tm->suspend_ms = data->suspend_ms;
tm->wake_ms = data->wake_ms;
}
#ifdef CONFIG_PM_AUTO_TEST_SUSPEND
/*
*init clk
*/
#if 0
tm->clk = clk_get(&pdev->dev, WAKEUP_TIMER_NAME);
if(IS_ERR(tm->clk)) {
dev_err(&pdev->dev,"get wake_timer clock failed");
return PTR_ERR(tm->clk);
}
#endif
#ifdef CONFIG_PM_WAKEUP_DEVICE_AUTO_TEST_SUSPEND
retval = register_test_input_dev(tm);
if(retval){
dev_err(&pdev->dev,"register test input dev failed");
goto free_wake_timer;
}
#endif
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if(!res) {
dev_err(&pdev->dev,"get_resource failed");
retval = -ENXIO;
goto free_wake_timer;
}
tm->mmio = ioremap_nocache(res->start,resource_size(res));
if(!tm->mmio) {
dev_err(&pdev->dev,"ioremap failed");
retval = -ENOMEM;
goto free_wake_timer;
}
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if(!res) {
dev_err(&pdev->dev,"get_resource failed");
retval = -ENXIO;
goto unmap_mmio;
}
tm->irq[0] = res->start;
tm->irq[1] = res->start+1;
retval = request_irq(tm->irq[0], wake_timer_irq, 0,\
WAKEUP_TIMER_NAME, tm);
if(retval < 0) {
dev_err(&pdev->dev,"request_irq %d failed",tm->irq[0]);
retval = -ENXIO;
goto unmap_mmio;
}
retval = request_irq(tm->irq[1], wake_timer_irq, 0, \
WAKEUP_TIMER_NAME, tm);
if(retval < 0) {
dev_err(&pdev->dev,"request_irq %d failed", tm->irq[1]);
retval = -ENXIO;
goto free_irq_0;
}
wake_lock_init(&(tm->wake_lock), WAKE_LOCK_SUSPEND,
WAKEUP_TIMER_WAKELOCK_NAME);
device_init_wakeup(&pdev->dev, false);
retval = pm_runtime_set_active(&pdev->dev);
if(retval) {
dev_err(&pdev->dev, "pm runtime set active failed %d", retval);
}
pm_runtime_enable(&pdev->dev);
platform_set_drvdata(pdev, tm);
enable_timer(tm, RT_MS, 1);
return retval;
free_irq_0:
free_irq(tm->irq[0], tm);
unmap_mmio:
iounmap(tm->mmio);
free_wake_timer:
kfree(tm);
#endif /*CONFIG_PM_AUTO_TEST_SUSPEND*/
out:
return retval;
}