demp_debug.c

/*-This file intends to record the demp information(including the taskID,swap count)-*/
//Fay.Wang build this file in 2011.3.7

#ifdef __MTK_TARGET__

#include "jrd_demp_debug.h"
#include "jrd_demp_debug_inc.h"

#ifdef __JRD_DEMP_DEBUG__
    #pragma arm section rwdata = "INTSRAM_RW"
    kal_uint32 fault_happened,swapin,swapout,swapin_by_another_fault=0;
    #pragma arm section rwdata
#endif  

void Demp_construct_internal_message(ilm_struct* ilm_ptr,local_para_struct* local_para_ptr,peer_buff_struct* peer_buff_ptr,msg_type message_ID);
void demp_usage_record_c(void);
void Demp_Self_Start(void);

demp_record task[RECORD_NUMBER_PER_RUN];
swap_count demp_count;
kal_taskid task_id;
kal_uint8 *task_name_ptr;
kal_uint16 task_index;
kal_uint8 demp_flag=0;
kal_uint8 demp_timer_inited=0;
stack_timer_struct demp_timer;
extern void mmi_msg_send_ext_queue(ilm_struct *message);
extern task_info_struct *task_info_g;
extern void mmi_display_popup(kal_uint16* string, kal_uint32 event_id);
extern void DisplayIdleScreen(void);

void $Sub$$demp_recorder_run (ilm_struct* para_ptr,ilm_struct* int_msg)
{
    kal_uint32 irq;
  

    if ((para_ptr->msg_id == MSG_ID_DEMPRECORD_START)||(int_msg->msg_id == MSG_ID_DEMPRECORD_START))
        {
            Record_again:
            irq = SaveAndSetIRQMask();
            stack_start_timer(&demp_timer,DEMP_TIMER,100);
            demp_flag=0xFF;
            RestoreIRQMask(irq);
        }
    else if((para_ptr->msg_id == MSG_ID_DEMPRECORD_STOP)||(int_msg->msg_id == MSG_ID_DEMPRECORD_STOP))
        {
            irq = SaveAndSetIRQMask();
            stack_stop_timer(&demp_timer);
            demp_flag=0;
            RestoreIRQMask(irq);
        }
    else if((para_ptr->msg_id == MSG_ID_TIMER_EXPIRY)||(int_msg->msg_id == MSG_ID_TIMER_EXPIRY))
        {
            demp_usage_record_c();
            stack_stop_timer(&demp_timer);
            goto Record_again;
        }
    else
        {
   //process on other message
        }
     
}
void Demp_construct_internal_message(ilm_struct* ilm_ptr,local_para_struct* local_para_ptr,peer_buff_struct* peer_buff_ptr,msg_type message_ID)
{
//    ilm_struct send_ilm;
    ilm_ptr->src_mod_id = MOD_DEMP_RECORDER;
    ilm_ptr->dest_mod_id = MOD_DEMP_RECORDER;
    ilm_ptr->local_para_ptr = local_para_ptr;
    ilm_ptr->peer_buff_ptr = peer_buff_ptr;
    ilm_ptr->msg_id = message_ID;
}

#ifdef    __JRD_DEMP_DEBUG_AUTO__       
void Demp_Self_Start(void)
{
    ilm_struct* send_ilm=allocate_ilm(MOD_DEMP_RECORDER);
    send_ilm->src_mod_id = MOD_DEMP_RECORDER;
    send_ilm->dest_mod_id = MOD_DEMP_RECORDER;
    send_ilm->local_para_ptr = NULL;
    send_ilm->peer_buff_ptr = NULL;
    send_ilm->msg_id = MSG_ID_DEMPRECORD_START;

//    Demp_construct_internal_message(&send_ilm,NULL,NULL,MSG_ID_DEMPRECORD_START);
  
    msg_send_int_queue(send_ilm);
   
    }
void Demp_Self_Stop(void)
{
//    ilm_struct* send_ilm=allocate_ilm(MOD_DEMP_RECORDER);
    ilm_struct* send_ilm=allocate_ilm(MOD_DEMP_RECORDER);

send_ilm->src_mod_id = MOD_DEMP_RECORDER;
send_ilm->dest_mod_id = MOD_DEMP_RECORDER;
send_ilm->local_para_ptr = NULL;
send_ilm->peer_buff_ptr = NULL;
send_ilm->msg_id = MSG_ID_DEMPRECORD_STOP;

//    Demp_construct_internal_message(send_ilm,NULL,NULL,MSG_ID_DEMPRECORD_STOP);
   
    msg_send_int_queue(send_ilm);
   
    }   
#endif

void SSHandleDempRecordSwitch(void)
{
//    PRINT_INFORMATION("This is to start the demp record");
    ilm_struct send_ilm;
    send_ilm.src_mod_id = MOD_MMI;
    send_ilm.dest_mod_id = MOD_DEMP_RECORDER;
    send_ilm.local_para_ptr = NULL;
    send_ilm.peer_buff_ptr = NULL;
    demp_flag=~demp_flag;
    if(demp_flag)
        {
            send_ilm.msg_id = MSG_ID_DEMPRECORD_START;
        }
    else
        {
            send_ilm.msg_id = MSG_ID_DEMPRECORD_STOP;
        }
    mmi_msg_send_ext_queue(&send_ilm);
    DisplayIdleScreen();
    if(demp_flag)
        {
            mmi_display_popup((kal_uint16*) (START_RECORD),1);
        }
    else
        {
            mmi_display_popup((kal_uint16*) (STOP_RECORD),1);
        }

}

void Monitor_init_timer_For_demp_record(void)
{
    stack_init_timer(&demp_timer,"DEMP_TIMER",MOD_DEMP_RECORDER);
    demp_timer.timer_indx=DEMP_TIMER;

}

kal_bool demp_recorder_init(task_indx_type task_indx)
{
//Init a timer for Monitor task first   
    Monitor_init_timer_For_demp_record();
//Others things to do...

    return KAL_TRUE;
   

}

   
void $Sub$$demp_recorder_entry (task_entry_struct *pTaskEntry)
{
    kal_uint32 myIndex;
    ilm_struct current_ilm;
//    stack_int_set_active_module_id(INDX_DEMP_RECORDER,MOD_DEMP_RECORDER);
    kal_get_my_task_index (&myIndex);
    stack_set_active_module_id (myIndex, MOD_DEMP_RECORDER);
#ifdef    __JRD_DEMP_DEBUG_AUTO__
            kal_sleep_task (1000);

            Demp_Self_Start();
#endif

    while(1)
        {
        while (receive_msg_int_q(pTaskEntry->task_indx, &current_ilm))
        {
        demp_recorder_run(NULL,&current_ilm);
        free_ilm(&current_ilm);
        }

       
            receive_msg_ext_q(task_info_g[pTaskEntry->task_indx].task_ext_qid, &current_ilm);
            demp_recorder_run(&current_ilm,NULL);
              free_ilm(&current_ilm);

           
        }
}

void demp_usage_record_c(void)
{
    int fHdl,fHdl_task_count;
    kal_uint32 size;
    kal_uint16 index_copy=task_index;
    unsigned int Written;

    fHdl = FS_Open(DEMAND_PAGING_RECORDER, FS_CREATE|FS_READ_WRITE);
    FS_GetFileSize(fHdl,&size);
    if(size>=MAX_FILE_SZIE)
    {
    demp_flag=0;
    task_index = 0;
    Demp_Self_Stop();
    FS_Close(fHdl);
    mmi_display_popup((kal_uint16*) (FILE_LIMIT),1);
    return;
    }
    if(fHdl <= 0)
        { EXT_ASSERT(0,fHdl,0,0);}
    FS_Seek(fHdl, 0, 2);
    FS_Write(fHdl, &demp_count, sizeof(swap_count), &Written);
    FS_Close(fHdl);   
    Written = 0;
    if(index_copy>0)
    {
    fHdl_task_count = FS_Open(DEMAND_PAGING_RECORDER_TASK_COUNT, FS_CREATE|FS_READ_WRITE);
    FS_GetFileSize(fHdl_task_count,&size);
    if(size>=MAX_FILE_SZIE)
    {
    demp_flag=0;
    task_index = 0;
      Demp_Self_Stop();
      FS_Close(fHdl_task_count);
    mmi_display_popup((kal_uint16*) (FILE_LIMIT),1);
    return;
    }
    if(fHdl_task_count <= 0)
        { EXT_ASSERT(0,fHdl_task_count,0,0);}
    FS_Seek(fHdl_task_count, 0, 2);
    FS_Write(fHdl_task_count,&index_copy, sizeof(kal_uint16), &Written);
    FS_Write(fHdl_task_count,task, ((sizeof(demp_record))*index_copy), &Written);   
    FS_Close(fHdl_task_count);
    task_index = 0;
    }
}
#endif