Sunday, December 13, 2015

getch and kbhit in Linux

kbhit():

#include
int kbhit(void);
int kbhit(void) {
   struct termios term, oterm;
   int fd = 0;
   int c = 0;
   tcgetattr(fd, &oterm);
   memcpy(&term, &oterm, sizeof(term));
   term.c_lflag = term.c_lflag & (!ICANON);
   term.c_cc[VMIN] = 0;
   term.c_cc[VTIME] = 1;
   tcsetattr(fd, TCSANOW, &term);
   c = getchar();
   tcsetattr(fd, TCSANOW, &oterm);
   if (c != -1)
   ungetc(c, stdin);
   return ((c != -1) ? 1 : 0);
}
und getch():

#include
int getch();
int getch()
{
   static int ch = -1, fd = 0;
   struct termios neu, alt;
   fd = fileno(stdin);
   tcgetattr(fd, &alt);
   neu = alt;
   neu.c_lflag &= ~(ICANON|ECHO);
   tcsetattr(fd, TCSANOW, &neu);
   ch = getchar();
   tcsetattr(fd, TCSANOW, &alt);
   return ch;
}

<

Friday, October 16, 2015

GCC ARM porting

ARM Cortex-A Processors and GCC Command Lines




Debugging on bare-metal targets using DS-5 and GCC compiler
http://ds.arm.com/debugging-on-bare-metal-targets-using-ds-5-and-gcc-compiler/




Renesas – GNURX Migration Guide
http://www.kpitgnutools.com/manuals/Renesas-GNURX-Migration-Guide.html




ARMv7A - Thumb 2
http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0344b/CACCICED.html






arm-none-eabi-gcc --target-help
arm-none-eabi-as --target-help






https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html


Four Important properties:
Byte order = little
Floating-point ABI = Default
Instruction set = Arm
Interworking = Checked




$(TCINSTALL)\arm-none-eabi\arm-none-eabi\lib\gcc\arm-none-eabi\ 4.8-GNUARM-NONE_v14.01\interwork




Cerating archive file using GCC
http://www.cs.dartmouth.edu/~campbell/cs50/buildlib.html


Different single line comment for each platform
https://en.wikipedia.org/wiki/GNU_Assembler
Single-Line comments[edit]
Single line comments have a few different formats varying on which architecture is being assembled for.
•Hash symbols (#) are used for the platforms: i386, x86-64, i960, 68HC11, 68HC12, VAX, V850, M32R, PowerPC, MIPS and M880x0.
•Semicolons (;) are used on: AMD 29k family, ARC, H8/300 family, HPPA, PDP-11, picoJava, Motorola, and M32C.
•The at sign (@) is used on the ARM platform.
•A vertical bar (|) is used to signify comments when assembling on 680x0.
•An exclamation mark (!) on the Renesas SH platform.
Preprocess source file GCC
http://www.linuxtopia.org/online_books/an_introduction_to_gcc/gccintro_36.html




NEON:
#define __ARM_NEON__ 1
#define __ARM_NEON 1


NEON_D16:




Very good assembly
http://shervinemami.info/armAssembly.html




Check:


1) in Thumb mode, functions addresses are in thumb and CPU is in thumb mode














d




VFPv3 and VFPv4 has D32 only in  case of having NEON. Otherwise they have only 16 64-bit registers.
http://dench.flatlib.jp/opengl/fpu_vfp

























Re: ARM: VFPv3-D16 vs. VFPv3-D32
https://gcc.gnu.org/ml/gcc/2013-10/msg00183.html

SWI Call:

<>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
/* vi: set sw=4 ts=4: */
/* syscall for arm/uClibc
 *
 * Copyright (C) 2002 by Erik Andersen 
 *
 * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball.
 */

#include 
#include 
#include 
#include 


long syscall(long sysnum, long a, long b, long c, long d, long e, long f)
{
#if !defined(__thumb__)
 register long _r0 __asm__("r0")=(long)(sysnum);
 register long _r6 __asm__("r6")=(long)(f);
 register long _r5 __asm__("r5")=(long)(e);
 register long _r4 __asm__("r4")=(long)(d);
 register long _r3 __asm__("r3")=(long)(c);
 register long _r2 __asm__("r2")=(long)(b);
 register long _r1 __asm__("r1")=(long)(a);
 __asm__ __volatile__(
   "swi %1"
   : "=r"(_r0)
   : "i"(__NR_syscall), "r"(_r0), "r"(_r1),
   "r"(_r2), "r"(_r3), "r"(_r4), "r"(_r5),
   "r"(_r6)
   : "memory");
#else
 register long _r7 __asm__("r7")=(long)(sysnum);
 register long _r5 __asm__("r5")=(long)(f);
 register long _r4 __asm__("r4")=(long)(e);
 register long _r3 __asm__("r3")=(long)(d);
 register long _r2 __asm__("r2")=(long)(c);
 register long _r1 __asm__("r1")=(long)(b);
 register long _r0 __asm__("r0")=(long)(a);
 __asm__ __volatile__(
   "swi 0"
   : "=r"(_r0)
   : "r"(_r0), "r"(_r1), "r"(_r2), "r"(_r3),
   "r"(_r4), "r"(_r5), "r"(_r7)
   : "memory");
#endif
 if(_r0 >=(unsigned long) -4095) {
  long err = _r0;
  (*__errno_location())=(-err);
  _r0=(unsigned long) -1;
 }
 return (long) _r0;
}



http://embdev.net/topic/129714
static inline int Do_SWI_9 (int arg1, struct something *arg2)
{
  register long __res asm("r0");
  asm volatile ("mov r0,%2\n\tmov r1,%3" : \
      "=X" (*(char *)(long)arg1), "=X" (*(char *)(long)arg2) : \
      "r" ((long)arg1), "r" ((long)arg2) : \
      "r0", "r1");
  asm volatile ("swi 9 @ %0" : "=r" (__res) : :
      "r12", "r14", "cc");
  return((int)__res);
}

What's different?
(1) The __res variable is now explicitly placed in r0.
(2) The swi call is marked as returning a value in __res.
(3) The "@%0" comment after swi FOOLS asm() into thinking swi really
does affect r0.
(4) The "mov %0,r0" after the swi is omitted as it's no longer
necessary.

Is this voodoo or what?  But it appears to work great under level 2
optimization.


http://embdev.net/topic/184418

In this case, the parameres are transmitted through the stack, but I do 
not need. When used inline it fits into the function.

How do I type this, an unspecified number of parameters?

_inline_ void sm(int i, int l)

{
   register int p0 asm("r0") = i;
   register int p1 asm("r1") = l;

   asm ("swi 0x148"::"r"(p0),"r"(p1));

}


_inline_ void sm(int i,...)

-------------------------------------------------------------


http://venkateshabbarapu.blogspot.jp/2012/09/interrupt-handling-in-arm.html




それでは、L1 命令キャッシュ、L1 データキャッシュ、L2 統一キャッシュをどのような手順で有効化するかというと、

・L1 命令キャッシュをすべて invalidate する
・L1 データキャッシュをすべて invalidate する
・L2 統一キャッシュをすべて invalidate する
・Control Register の I ビットを立てて L1 命令キャッシュを有効化する
・MMU を有効化する
   - ページテーブルを構成する
   - Translation Table Base Register にページテーブル先頭アドレスを設定する
   - Control Register の M ビットを立てて MMU を有効化する
・Auxiliary Control Register の L2EN ビットを立てる
・Control Register の C ビットを立てて、L1 データキャッシュ、L2 統一キャッシュを有効化する

という方法でいいと思います。

分岐予測を有効にする場合は、更に以下を行います:

・分岐予測器を invalidate する
・Control Register の Z ビットを立てて分岐予測を有効化する























Wednesday, October 14, 2015

Task dependent synchronization: rel_wai vs wup_tsk

wup_tsk requests are queued up. So, it can be issued for self too. But, rel_wai is issued against a waiting one to just exit from waiting. So, it cannot be issued for self. Some of the differences listed in uITRON specification are as follows:

  • rel_wai releases a task from any waiting state, while wup_tsk only releases a task from the sleeping state
  • To the task in the sleeping state, a success (E_OK) is returned when the task is released from sleeping with slp_tsk, while an error (E_RLWAI) is returned when the task is forcibly released from waiting with rel_wai.
  • wup_tsk will increment the wakeup request count if the task is not in the sleeping state. On the other hand, rel_wai will return E_OBJ error if the task is not waiting.


iTRON implementation of rel_wai()

ER rel_wai(ID tskid)
{
        if (tskid is TSK_SELF)
                return E_OBJ;
        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        Enter critical section
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;
        Take status from TCB
        if (waiting with timeout) {
                clear the waiting with timeout flag;
                remove from timer queue;
        }
        if (waiting for any resource) {
                make status as Ready
                set error code as E_RLWAI;
                if (resource is mutex) {
                        get the mutex waiting for
                        delete from the wait queue
                        if (inheritence protocol) && tcb priority is equal or
                        higher than ceiling)
                                rearrange_priority_for_mutex(taskid locking mutex);
                        if (suspend count is zero) { /* ??? */
                                /* Why without any condition, anonymously dispatch is performed */
                                add to Ready queue and dispatch;
                                return;
                        } else { /* suspended */
                                exit critical section;
                                return;
                        }
                } else if (resource is message buffer or variable memory pool){
                        remove from waiting queue;
                        if (suspend count is zero)
                                /* change to Ready queue; */ /* ??? */
                                should be add to Ready queue as removed above.
                        There is chance for new task to get chance, try it.
                        If (there is alteration in try or this task
                        priority is higher than application priority) {
                                dispatch();
                                return;
                        } else {
                                exit critical section;
                                return;
                        }
                } /* Waiting for any other resources */
                else if (suspension count is zero) {
                        change to ready queue;
                        dispatch;
                        return;
                } else { /* Under suspension */
                        just remove from waiting queue;
                        exit critical section;
                        return;
                }
        }
        /* Finally sleep or dly task */
        if (status is sleeping or delay task or rendezvous completion wait) {
                make tcb status as Ready;
                set error code as E_RLWAI;
                /* already removed from Timer queue if waiting in */
                if (suspension count is zero) {
                        add to ready queue;
                        dispatch;
                        return;
                } else { /* Under suspension */
                        just remove from waiting queue;
                        exit critical section;
                        return;
                }
        }
        Exit critical section;
        Return E_OBJ;
}

Hey, no need to do it! Return back immediately !!

Monday, October 12, 2015

ARMv7-A Linux kenrel compile: Compiler and Assembler flags

  arm-poky-linux-gnueabi-gcc -Wp,-MD,arch/arm/kernel/.sleep.o.d  -nostdinc -isystem /opt/poky/1.5+snapshot/sysroots/i686-pokysdk-linux/usr/lib/arm-poky-linux-gnueabi/gcc/arm-poky-linux-gnueabi/4.8.2/include -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include -Iarch/arm/include/generated  -Iinclude -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include/uapi -Iarch/arm/include/generated/uapi -I/opt/kernel/kernel-E2-116f7e6/include/uapi -Iinclude/generated/uapi -include /opt/kernel/kernel-E2-116f7e6/include/linux/kconfig.h -D__KERNEL__ -mlittle-endian  -D__ASSEMBLY__ -mabi=aapcs-linux -mno-thumb-interwork -marm -D__LINUX_ARM_ARCH__=7 -march=armv7-a  -include asm/unified.h -msoft-float -gdwarf-2         -c -o arch/arm/kernel/sleep.o arch/arm/kernel/sleep.S

  arm-poky-linux-gnueabi-gcc -Wp,-MD,arch/arm/kernel/.head.o.d  -nostdinc -isystem /opt/poky/1.5+snapshot/sysroots/i686-pokysdk-linux/usr/lib/arm-poky-linux-gnueabi/gcc/arm-poky-linux-gnueabi/4.8.2/include -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include -Iarch/arm/include/generated  -Iinclude -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include/uapi -Iarch/arm/include/generated/uapi -I/opt/kernel/kernel-E2-116f7e6/include/uapi -Iinclude/generated/uapi -include /opt/kernel/kernel-E2-116f7e6/include/linux/kconfig.h -D__KERNEL__ -mlittle-endian  -D__ASSEMBLY__ -mabi=aapcs-linux -mno-thumb-interwork -marm -D__LINUX_ARM_ARCH__=7 -march=armv7-a  -include asm/unified.h -msoft-float -gdwarf-2      -DTEXT_OFFSET=0x00008000   -c -o arch/arm/kernel/head.o arch/arm/kernel/head.S

  arm-poky-linux-gnueabi-gcc -Wp,-MD,drivers/iccom/.iccom_drv_com.o.d  -nostdinc -isystem /opt/poky/1.5+snapshot/sysroots/i686-pokysdk-linux/usr/lib/arm-poky-linux-gnueabi/gcc/arm-poky-linux-gnueabi/4.8.2/include -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include -Iarch/arm/include/generated  -Iinclude -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include/uapi -Iarch/arm/include/generated/uapi -I/opt/kernel/kernel-E2-116f7e6/include/uapi -Iinclude/generated/uapi -include /opt/kernel/kernel-E2-116f7e6/include/linux/kconfig.h -D__KERNEL__ -mlittle-endian -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -Werror-implicit-function-declaration -Wno-format-security -fno-delete-null-pointer-checks -Os -Wno-maybe-uninitialized -fno-dwarf2-cfi-asm -fno-omit-frame-pointer -mapcs -mno-sched-prolog -mabi=aapcs-linux -mno-thumb-interwork -marm -D__LINUX_ARM_ARCH__=7 -march=armv7-a -msoft-float -Uarm -Wframe-larger-than=1024 -fno-stack-protector -Wno-unused-but-set-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-overflow -fconserve-stack -DCC_HAVE_ASM_GOTO    -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(iccom_drv_com)"  -D"KBUILD_MODNAME=KBUILD_STR(iccom)" -c -o drivers/iccom/iccom_drv_com.o drivers/iccom/iccom_drv_com.c

  arm-poky-linux-gnueabi-gcc -Wp,-MD,init/.version.o.d  -nostdinc -isystem /opt/poky/1.5+snapshot/sysroots/i686-pokysdk-linux/usr/lib/arm-poky-linux-gnueabi/gcc/arm-poky-linux-gnueabi/4.8.2/include -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include -Iarch/arm/include/generated  -Iinclude -I/opt/kernel/kernel-E2-116f7e6/arch/arm/include/uapi -Iarch/arm/include/generated/uapi -I/opt/kernel/kernel-E2-116f7e6/include/uapi -Iinclude/generated/uapi -include /opt/kernel/kernel-E2-116f7e6/include/linux/kconfig.h -D__KERNEL__ -mlittle-endian -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs -fno-strict-aliasing -fno-common -Werror-implicit-function-declaration -Wno-format-security -fno-delete-null-pointer-checks -Os -Wno-maybe-uninitialized -fno-dwarf2-cfi-asm -fno-omit-frame-pointer -mapcs -mno-sched-prolog -mabi=aapcs-linux -mno-thumb-interwork -marm -D__LINUX_ARM_ARCH__=7 -march=armv7-a -msoft-float -Uarm -Wframe-larger-than=1024 -fno-stack-protector -Wno-unused-but-set-variable -fno-omit-frame-pointer -fno-optimize-sibling-calls -g -Wdeclaration-after-statement -Wno-pointer-sign -fno-strict-overflow -fconserve-stack -DCC_HAVE_ASM_GOTO    -D"KBUILD_STR(s)=#s" -D"KBUILD_BASENAME=KBUILD_STR(version)"  -D"KBUILD_MODNAME=KBUILD_STR(version)" -c -o init/version.o init/version.c

+ arm-poky-linux-gnueabi-ld -EL -p --no-undefined -X --build-id -o vmlinux -T /opt/kernel/kernel-E2-116f7e6/arch/arm/kernel/vmlinux.lds arch/arm/kernel/head.o init/built-in.o --start-group usr/built-in.o arch/arm/vfp/built-in.o arch/arm/kernel/built-in.o arch/arm/mm/built-in.o arch/arm/common/built-in.o arch/arm/net/built-in.o arch/arm/crypto/built-in.o arch/arm/mach-shmobile/built-in.o kernel/built-in.o mm/built-in.o fs/built-in.o ipc/built-in.o security/built-in.o crypto/built-in.o block/built-in.o arch/arm/lib/lib.a lib/lib.a arch/arm/lib/built-in.o lib/built-in.o drivers/built-in.o sound/built-in.o firmware/built-in.o net/built-in.o --end-group .tmp_kallsyms2.o

  arm-poky-linux-gnueabi-ld -EL    --defsym _kernel_bss_size=219604 -p --no-undefined -X -T arch/arm/boot/compressed/vmlinux.lds arch/arm/boot/compressed/head.o arch/arm/boot/compressed/piggy.gzip.o arch/arm/boot/compressed/misc.o arch/arm/boot/compressed/decompress.o arch/arm/boot/compressed/debug.o arch/arm/boot/compressed/string.o arch/arm/boot/compressed/hyp-stub.o arch/arm/boot/compressed/lib1funcs.o arch/arm/boot/compressed/ashldi3.o -o arch/arm/boot/compressed/vmlinux
 




  arm-poky-linux-gnueabi-objcopy -O binary -R .comment -S  arch/arm/boot/compressed/vmlinux arch/arm/boot/zImage






Tuesday, September 15, 2015

Task dependent synchronization: Sleep Task, Wake-up Task and Cancel Wake-up

Sleep Task

ER tslp_tsk(TMO tmout)
{

        Sanity check of context and arguments
        if (interrupt context or dispatch disabled state or Timer or overrun
         handlers)
                return E_CTX;

        Take Task ID of current running task
        Take TCB
        Enter critical section
        Take number of pending wakeups
        if (No pending wakeup) {
                if (Not polling) {
                        if (timeout is NOT FOREVER) {
                                add taks to timer queue;
                                make tcb status as SLEEP with TIMEOUT
                        } else /* forever timeout */
                                make tcb status just as SLEEP
                        }
                        remove task from Ready queue and dispatch
                        /* critical section is exit inside dispatch */
                        return error code from dispatch;
                }
                /* else, Polling */ {
                Exit critical section and return E_TMOUT; /* ?? Not needed */
                /* No polling service call is provided for slp_tsk- ITRON spec */
        }
        /* else, pending wakeups */
        Decrement the number of pending wake-ups by 1
        Exit critical section and return E_OK;
}

Wakeup Task

ER wup_tsk(ID tskid)
{
        if (tskid is TSK_SELF)
                Take taskid from Ready Queue[0]
        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        Enter critical section
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;
        Take status from TCB
        if (status is sleeping) {
                make the status as Ready
                if (Sleeping with TIMEOUT)
                        remove task from Timer queue
                if (Not suspended) {
                        add task to ready queue and dispatch
                        return;
                } /* Else, suspended */
                Exit critical section and just return E_OK;
        }
        /* Not sleeping */
        if (status is not Dormant) {
                increment pending wakeup count
                if (pending wakeup count does not exceed maximum)
                        exit critical section and return E_OK
                /* else, exceeded */
                assign wakeup count to the maximum
                exit critical section and return E_QOVR;
        }
        /* Dormant */
        exit critical section and return E_OBJ;
}

Cancel Wakeup Task

ER can_wup(ID tskid)
{
        if (tskid is TSK_SELF)
                Take taskid from Ready Queue[0]
        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        Enter critical section
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;
        else if (Task status is Dormat)
                return E_OBJ;
        else {
                Take backup of number of pending wakeup requests
                make pending wakeup counts as zero
        }
        Exit critical section
        return saved wake up counts;
}

Task Management: Get priority, Reference to Task State

Acquire Task Priority

ER get_pri(ID tskid, PRI *p_tskpri)
{
        if (tskid is TSK_SELF)
                Take taskid from Ready Queue[0]
        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        if (called from ISR and specified task id as SELF)
                return E_ID;

        if (task id is currently running one) {
                assign p_tskpri = Running priority from TCB;
                return E_OK
        }

        /* For any other task */
        Enter critical section;
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;
        if (Task status is Dormat)
                return E_OBJ;
        assign p_tskpri = Running priority from TCB;
        Exit critical section
        return E_OK;
}

Reference Task State

ER ref_tsk(ID tskid, T_RTSK *pk_rtsk)
{

        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        Enter critical section;

        if (tskid is TSK_SELF)
                Take taskid from Ready Queue[0]
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;

        Fill out following information from TCB
        pk_rtsk->tskpri
        pk_rtsk->tskbpri
        pk_rtsk->actcnt

        Take task status from TCB
        if (status is Dormant) {
                Exit critical section
                pk_rtsk->tskstat = TTS_DMT;
                Fill out all other fields with Zero.
                return E_OK;
        }

        Assign pk_rtsk->wupcnt from TCB;
        if (status is Ready) {
                if (Task is currently running) {
                        exit critical sections
                        Fill pk_rtsk->tskstat = TTS_RUN;
                        Fill suspension count as zero
                } else /* Not currently running */ {
                        Take suspension status from TCB
                        Exit critical section
                        Fill pk_rtsk->suscnt with the suspension count
                        If (task is not suspended)
                                Assign task state as TTS_RDY;
                        else
                                Assign task state as TTS_SUS;
                }
                /* Assign the following fields as zero */
                pk_rtsk->tskwait = 0;
                pk_rtsk->lefttmo = 0;
                pk_rtsk->wobjid = 0;
                return E_OK;
        }
        /* Status is not Ready */
        if (waiting in timer queue)
                assign pk_rtsk->lefttmo = TCB timeout - current system time;
        else
                assign pk_rtsk->lefttmo = TMO_FEVR;
        if (waiting in dlt_tsk call)
                pk_rtsk->wobjid = 0;
        else
                pk_rtsk->wobjid = Take the object id from the saved context;
        Take suspension status
        Exit critical section
        Assign pk_rtsk->suscnt with suspension count
        if (status is suspended)
                pk_rtsk->tskstat = WAITING state ;
        else
                pk_rtsk->tskstat = WAITING SUSPENDED state;
        Assign pk_rtsk->tskwait with WAITING Resource type
        return E_OK;
}

Simplified Reference Task State

ER ref_tst(ID tskid, T_RTST *pk_rtst)
{
        if (Task ID is greater than maximum of Task ID)
                return E_ID;
        Enter critical section;

        if (tskid is TSK_SELF)
                Take taskid from Ready Queue[0]
        Take TCB
        if (TCB == NULL)
                return E_NOEXS;

        Take task status from TCB
        if (status is Dormant) {
                Exit critical section
                pk_rtsk->tskstat = TTS_DMT;
                Fill out all other fields with Zero.
                return E_OK;
        }
        if (status is Ready) {
                if (Task is currently running) {
                        exit critical sections
                        Fill pk_rtsk->tskstat = TTS_RUN;
                } else /* Not currently running */ {
                        Take suspension status from TCB
                        Exit critical section
                        If (task is not suspended)
                                Assign task state as TTS_RDY;
                        else
                                Assign task state as TTS_SUS;
                }
                /* Assign the following fields as zero */
                pk_rtsk->tskwait = 0;
                return E_OK;
        }
        Take suspension status
        Exit critical section
        Assign pk_rtsk->suscnt with suspension count
        if (status is suspended)
                pk_rtsk->tskstat = WAITING state ;
        else
                pk_rtsk->tskstat = WAITING SUSPENDED state;
        Assign pk_rtsk->tskwait with WAITING Resource type
        return E_OK;
}

Timer Management: Timeout handler vs Cyclic Handler vs Alarm Handler


The Time management functions are called from idle task whenenver there is Timer interrupt. When there is timer interrupt, the priority of the Idle task (System task) is raised to the highest (0) and scheduling returns to the counting loop of the idle task. It skips the counting loop and disables the interupt to create the critical section and increments the timer count. And, it processes the timer tasks further.

Alarm handler and Cyclic handler are just executing handler at interrupt enabled context. Cyclic handler is cyclic. Alarm is just once. But, other timeout handler is not handler. Instead, waking up tasks sleeping at various resources and system calls with various reasons.

But, why two timeout redundant values? 1) Timeout queue 2) TCB timeout

System Dispatch Service

ER System Dispatch Functions(void)
{
        If (there is system error)
                return system error;
        Enable dispatch;
        Initializes internal strucutres;
        /* Enter endless loop */
        for (;;) {
                This task is assigned lowest priority in the system.
                Maximum priority + 1;
                If (Dispatch is disabled)
                        Special Dispatch task = Previous running task
                else
                        No special request
                Schedule and dispatch;

                if (overrun handler conndition )
                        Call Overrun handler

                /* counter loop */
                for (;;) {
                        count down and stay here if reached zero;
                        Poll for Timer interrup flag;
                        if (timer interrrupt flag is set )
                                break;
                }
                Get idle count;
                Enter critical section;/* diable interrupt */
                for (till number of pending timer interrupts reaches zero)
                        Update system clock;
                        check timer queue - Timeout check processing;
                        check cyclic handler management
                        check alarm handler management
                }
        }
}

Timeout check processing

void timeout_check_processing(void)
{

        Take queue corresponding to lower 32 bit of system time

        for (till there is valid entry in the head of the queue) {
                Take taskid in the head of the queue
                if (task id is zero)
                        return;
                Take TCB
                for (till an entry matching the timeout value is reached) {
                        if (matching) { /* ?? I think this will match always */
                                Remove the task from the timer queue;
                                Take backup of the task status
                                Assign the task status as READY
                                Assign the return code based on previous status
                                if (in Timer queue due to dly_tsk(DLY)) {
                                        Assign return code as E_OK
                                } else {
                                Assign return code as E_TIMEOUT
                                if (waiting for any resource) {
                                        delete from the resource's waiting queue
                                        if (resource is Mutex) {
                                                Get the Mutex ID
                                                if (Mutex is INHERITENCE and
                                                  priority is higher or equal
                                                        ceiling priority)
                                                        Adjust Mutex priority
                                        } else if (resource is Message buffer)
                                                adjust resource allocation
                                        } else if (resource is variable m-pool)
                                                adjust resource allocation
                                        }
                                }
                                if (not suspended) {
                                        Take priority
                                        if (priority is higher than current Application priority)
                                                Add to delayed Dispatch
                                                /* As this function won't call dispatch */
                                        Add to Ready queue of the task's priority
                                }
                                temporarily open and close critical
                                        section to open up the door for dispatch
                                break; /* Again go to head for check */
                                        /* Anything might have happened when you opened up the door */
                        }
                        if (reached end of queue)
                                return;
                        move to next task in the queue chain
                }
        }
}

Cyclic Handler Processing

void Cyclic_handler_processing(void)
{

        Take the cyclic handler queue corresponding to the system time low 32 bit
        for (till valid entry in the head of the queue) {
                Take the cyclic handler ID at the queue head
                if (cyclic handler ID is 0)
                        return;
                for (till an entry which matches with time stamp) {
                        if (deadline matches with time stamp) {
                                delete from cyclic handler queue
                                calculate new target time as it is cyclic handler
                                add to the new queue of new target time
                                temporarily enable interrupt
                                if (cyclic hander is ON now) {
                                        Execute cyclic handler
                                }
                                disable interrupt again
                                break; /* Restart from head again */
                                /* anything is possible in the cycle gap */
                        }
                        if (reached end of queue)
                                return;
                        move to next cyclic handler in the same queue
                }
        }
}

Alarm Handler Processing

void alarm_handler_processing(void)
{
        Take alarm handler queue corresponding to the system time low 32 bit
        for (till valid entry in the head of the queue) {
                for (till an entry which matches with time stamp) {
                        if (deadline matches with time stamp) {
                                delete from alarm handler queue
                                reset the alarm handler entry fields
                                temporarily enable interrupt
                                Execute alarm handler
                                disable interrupt again
                                break; /* Restart from head again */
                                /* anything is possible in the cycle gap */
                        }
                        if (reached end of queue)
                                return;
                        move to next alarm handler in the same queue
                }
        }
}

Accumulating or queuing inside system processing is not real-time. Realtime never accumulates in production center. Always, wherever there is a change in the system state, it opens the gate and put the car on the road. It is like Toyota. Never keep the doors closed.
Whether the car runs on the road or stands depends on the user program. But, kernel will pass the message always at real time.

Friday, September 04, 2015

Task Management: Change Task priority

① Change Task's base priority

There three kinds of priorities.

1) Initial priority - Assigned when Task is created through Task creation structure. Once taks is created, this will be base priority.
2) Base priority - Priority changed on runtime through chg_pri
3) Running priority - Unless otherwise Mutexes are locked, this will be same as base priority. But, when Mutexes are locked, running priority is changed according to priority inheritence algorithm.

When priority is changed, all operations which are based on priority needs to be realigned. Whether it is get_mpl, snd_mbf or waiting for mutex or locked mutex. Please note that the task needs to yield, if the current running priotiy is same as of it.

② uITRON Implementation of chg_pri()

ER chg_pri(ID tskid, PRI tskpri)
{
        if (TSK_SELF is specified as Task ID)
                Set tskid as ReadyQueue[0]
        Enter critical section
        Sanity check on arguments
        /* Dormant task, Timer tasks(idle tasks) cannot be target */
        /* ISR cannot specify TSK_SELF */
        Take TCB of target task ID
        if (target priority == TPRI_INI)
                take task priority from initialization structure
        yesmtx = check if target task has locked mutex or waiting for mutex

        /* Just changing the Base priority; Not running priority */
        /* When mutex is locked/waited, but target pri is lower than running pri */
        if (yesmtx) {
                if (target priority is higher than running priority) {
                        /* Whether the target pri is valid or not? */
                        for (all mutexes locked by target task) {
                                if (CEILING priority &&
                                        target pri is higher than ceiling pri) {
                                        return E_ILUSE;
                                }
                                MaxLocked = Get Maximum of Inherited&Ceiling pri of locked mutexes
                        }
                        /* Is the running not equal to Maximum of locked mutex priorites ????. So, I guess following will be false forever */
                        if (Target pri is lower than MaxLocked)
                                goto Just_exit
                }
                else (target pri is lower than running pri) {
Just_exit:              I cannot change running pri as mutex make running pri as higher
                        So, I just change base priority and leaving now.
                        Mutex functions will adjust the running further based on the base pri.
                }
        }

        /* Changing the Running priority too */
        Take back up of target task's current running pri;
        Assign target priority to both base as well as running priority
        If (Task is ReadyToRun and not suspended) {
                move the position of Task in the ReadyQueue
                if (task is running task and target pri is lesser/equal
                                 priority of current user task priority) {
                        OR
                (task is not Running and target pri is higher/equal priority of
                                current user task priority) {
                        /* if you are equal, I will dispatch */
                        /* if you are waiting and higher, then dispatch */
                        /* if you are running and become lower, then dispatch */
                        return dispatch();
                }
                /* I am still running after changing the priority */
                /* then update current running priority and current application priority */
                current running priority = target priority;
                if (current running priority != 0) { /* Reverse is not possible as system task cannot be target ??? */
                        current application priority = current running priority;
                }
                return;
        }

        /* No, the target guy is waiting for something */
        if (waiting for Resource) {
                Adjust the position in the queue if it is priority based queue
                (Not FIFO)
                if (waiting for Mutex) {
                        get the Mutex ID waiting for
                        if (Mutex is INHERITENCE based) {
                                Mutex priority should be equal to Top priority
                                task in the waiting queue
                                if (this is not true) /* above position adjustment caused this */
                                        realign the task priority of holding the mutex
                        }
                }
        } else if (waiting for Message buffer) {
                Check the change in position caused any advantage
                if (caused advantage)
                        return dispatch;
        } else if (waiting for Memory Pool) {
                Check the change in position caused any advantage
                if (caused advantage)
                        return dispatch;
        }
        exit critical section;
        return;
}

Changing priority - Adjusting the foundation..