[Xenomai] imx6q xenomai ipipe-3.0-imx6q

* [Xenomai] imx6q xenomai ipipe-3.0-imx6q
@ 2014-04-18 10:28 嵌入式工程师
  2014-04-18 11:47 ` Gilles Chanteperdrix
  0 siblings, 1 reply; 35+ messages in thread
From: 嵌入式工程师 @ 2014-04-18 10:28 UTC (permalink / raw)
  To: Gilles Chanteperdrix, xenomai, liu.h.f, huang.c.h

I do the same on the imx53 with imx6 test, in the process of real-time task to run the same operation content, start the qt deform demo and copy large file  to memory, in 250 us the  latency on imx6 board began to accumulate, lost real-time, but latency  on the imx53   only value within 20 us. I do not run anyother rt task on my below test：

#include <linux/module.h> 
#include <linux/types.h>  
#include <linux/fs.h>  
#include <linux/types.h>  
#include <linux/kernel.h>  
#include <linux/init.h>  
#include <linux/platform_device.h>  
#include <linux/cdev.h>  
#include <linux/ioctl.h>  
#include <linux/gpio.h>  
#include <linux/mm.h>  
#include <linux/errno.h>  
#include <asm/uaccess.h>  
#include <linux/slab.h>  
#include <asm/io.h> 
#include <linux/sched.h>  
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <nucleus/module.h>
#include <linux/string.h> 
#include <native/timer.h>
#include <native/alarm.h>
#include <native/task.h>
#include <native/sem.h>
#include <native/intr.h>
#include <native/heap.h>
#include <rtdm/rtdm_driver.h>
#include <native/pipe.h>
#include <linux/spinlock.h>
#include <linux/io.h>
#include <linux/ipipe.h>
#include <nucleus/timer.h>
#define TASK_PRIO 99 /* Highest RT priority */
#define TASK_MODE 0 /* No flags */
#define TASK_STKSZ 0 /* Stack size (use default one) */
RTIME now, previous;
RTIME pnow, pprevious;
rtdm_task_t t1,t2,t3;
//RT_SEM  semt1,semt2,semt3,irq_sem;
rtdm_sem_t semt1,semt2,semt3;
RT_HEAP heap_desc;
long * mem_spvm; 
void *block;
//static xntimer_t rtimer;
static rtdm_timer_t rtimer;

static IPIPE_DEFINE_SPINLOCK(mem_lock);
#define CAT_IRQ          IMX_GPIO_NR(5, 0)
MODULE_LICENSE("GPL");
int irq = -1;
#define HEARTBEAT_PERIOD250000 /* 100 ms */
static rtdm_task_t heartbeat_task,heartbeat_task1,heartbeat_task2;

static unsigned char logo[1024*10]={0};

long long tmp=0;
int irq_taskOne(int irq, void *device_id)
{
//rt_task_set_periodic(NULL,TM_NOW,250000);
//rt_sem_v(&irq_sem);
return RT_INTR_HANDLED;
}
long i;
long max,pmax;
int j;

void taskOne(void*arg)
{
previous = rt_timer_read();
pprevious=rt_timer_read();

while(1)
{
//rt_sem_p(&irq_sem,TM_INFINITE);
unsigned long flags;
pnow = rt_timer_read();
if(pmax<(long)(pnow - pprevious-tmp))
pmax=(long)(pnow - pprevious-tmp);
if(j<10000)
pmax=0;
if(i%20000==0){
rtdm_printk ("1task: %d.%06d ms\n",
     (int)(pnow - pprevious-tmp) / 1000000,
     (int)(pnow - previous-tmp) % 1000000);
rtdm_printk ("pmax: %ld.%06ld ms\n",(long)pmax/1000000,(long)pmax%1000000);
}
//spin_lock_irqsave(&mem_lock, flags);
memset(mem_spvm,0,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,0,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,0,sizeof(logo));
/*memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,0,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,0,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,0,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo));*/
//spin_unlock_irqrestore(&mem_lock, flags);
now = rt_timer_read();
if(max<(long)(now - previous-tmp))
max=(long)(now - previous-tmp);
if(j++<10000)
max=0;
if(i++%20000==0){
printk("1task: %d.%06d ms\n",
     (int)(now - previous-tmp) / 1000000,
     (int)(now - previous-tmp) % 1000000);
rtdm_printk ("1max: %ld.%06ld ms\n",(long)max/1000000,(long)max%1000000);
rtdm_printk ("spvm6: %d \n",(char)mem_spvm[6]);
rtdm_printk ("spvm1: %d  ",(char)mem_spvm[sizeof(logo)]);
}
tmp=tmp+250000; 
rtdm_sem_up(&semt1);
//rt_sem_v(&semt2);
//rt_task_wait_period(NULL);
rtdm_task_wait_period();
}
}

void taskTwo(void*arg)
{
int i=0;
long max=0;
while(1)
{
//rt_sem_p(&semt2,TM_INFINITE);
rtdm_sem_down(&semt1) ;
now = rt_timer_read();
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo)); 
if(i++%20000==0){
rtdm_printk ("2spvm6: %d \n",(char)mem_spvm[6]);
rtdm_printk ("2spvm1: %d\n",(char)mem_spvm[sizeof(logo)]);
}

rtdm_sem_up(&semt2);
}
}

void taskThree(void*arg)
{

int i;
while(1)
{
rtdm_sem_down(&semt2) ;
memset(mem_spvm,255,sizeof(logo));
memcpy(mem_spvm,logo,sizeof(logo)); 
if(i++%20000==0){
rtdm_printk ("3spvm6: %d \n",(char)mem_spvm[6]);
rtdm_printk ("3spvm1: %d\n",(char)mem_spvm[sizeof(logo)]);
}
}
}

#define HEAP_SIZE (15*1024*1024)

#define HEAP_MODE 0  /* Local heap. */
RT_INTR intr_desc;
static int periode_us = 1000;
static int __init rtex_init(void){

int ret,err;
/*err = gpio_request(CAT_IRQ,NULL);
if(err < 0){
printk("gpio_request failure !\n");
return err;
}
err = gpio_direction_input(CAT_IRQ);
if(err < 0){
printk("gpio_direction_input failure !\n");
return err;
}
irq = gpio_to_irq(CAT_IRQ);
irq_set_irq_type(irq,IRQ_TYPE_EDGE_RISING);
err = rt_intr_create(&intr_desc,"MyIrq",irq,irq_taskOne,NULL,I_SHARED|I_EDGE);
if(err){
printk("rt_intr_create failure !\n");
return err;
}
printk("rt_intr_create  irq=%d\n",irq);
rt_intr_enable(&intr_desc);
printk("I have enable the irq\n");*/

/*err =rt_heap_create(&heap_desc,"MyHeapName1",HEAP_SIZE,HEAP_MODE);
if (err)
printk("rt_heap_create wrong\n");
err = rt_heap_alloc(&heap_desc,1024*1024,TM_INFINITE,&block);
if (err)
printk("rt_heap_alloc wrong\n");*/
block=(long*)rtdm_malloc(1024*11);
mem_spvm=(long*)block;
if(mem_spvm == NULL ) 
              printk("mem_spvm failed!\n"); 
        else 
              printk("mem_spvm successfully! \naddr = 0x%lx\n",(unsigned long)mem_spvm); 

/*rt_sem_create(&semt1,"",0,S_FIFO);
rt_sem_create(&semt2,"",0,S_FIFO);
rt_sem_create(&semt3,"",0,S_FIFO);
rt_sem_create(&irq_sem,"",0,S_FIFO);*/
rtdm_sem_init(&semt1,0) ;
rtdm_sem_init(&semt2,0) ;
rtdm_sem_init(&semt3,0) ;
/*if(!rt_task_create(&t1, "task1", 4096, 99, T_FPU|T_CPU(0)))
rt_task_start(&t1, taskOne, NULL);*/
/*if(!rt_task_create(&t2, "task2", 4096, 85, T_FPU|T_CPU(1)))
rt_task_start(&t2, taskTwo, NULL);
if(!rt_task_create(&t3, "task3", 4096, 80, T_FPU|T_CPU(2)))
rt_task_start(&t3,taskThree, NULL);*/
printk("mem_spv ! \naddr = 0x%lx\n",(unsigned long)mem_spvm);
        rtdm_task_init(&heartbeat_task, "heartbeat", taskOne, NULL,
     99, HEARTBEAT_PERIOD);

     rtdm_task_set_period(&heartbeat_task,250000) ;
rtdm_task_set_priority(&heartbeat_task,99);
rtdm_task_unblock(&heartbeat_task);
printk("mem_spvm successfully! \naddr = 0x%lx\n",(unsigned long)mem_spvm);
rtdm_task_init(&heartbeat_task2, "heartbeat1", taskThree, NULL,
     80, HEARTBEAT_PERIOD);
rtdm_task_init(&heartbeat_task1, "heartbeat1", taskTwo, NULL,
     85, HEARTBEAT_PERIOD);
//xnticks_t now;
//now = xntbase_get_jiffies(&nktbase);
/*if ((err = rtdm_timer_init(& rtimer, taskOne, "Oscillateur")) != 0) {
return err;
}
if ((err = rtdm_timer_start(& rtimer, periode_us*250, periode_us*250, RTDM_TIMERMODE_RELATIVE)) != 0) {
rtdm_timer_destroy(& rtimer);
return err;
}*/
/*xntbase_enabled_p(&nktbase);
xntimer_init(&rtimer, &nktbase, taskOne);

xntimer_set_priority(&rtimer, XNTIMER_HIPRIO);
xntimer_start(&rtimer, 250000UL, 250000UL, XN_RELATIVE);*/

 return ret; 

}

static void __exit rtex_exit(void)
{

//rt_heap_free(&heap_desc,block);
//rt_heap_delete(&heap_desc);
rtdm_free(block); 
rtdm_task_join_nrt(&heartbeat_task, 100);
//rt_task_delete(&t1);
rt_task_delete(&t2);
rt_task_delete(&t3);
printk("rtex_exit \n");
}
module_init(rtex_init);
module_exit(rtex_exit);

^ permalink raw reply	[flat|nested] 35+ messages in thread