Hello, dear friend, you can consult us at any time if you have any questions, add WeChat: daixieit

CSS422 Final Project

Thumb-2 Implementation Work of Memory/Time-Related C Standard Library Functions.

The driver.c we use is shown in listing 1. It tests all the above six stdlib functions. Please note that printf() in the code will be removed when you test your assembly implementation, because we won’t implement the printf( ) standard function.

Listing 1: driver.c program to test your implementation

#include  // bzero, strncpy

#include  // malloc, free

#include  // signal

#include  // alarm

#include   // printf

int* alarmed;

void sig_handler1( int signum ) {

*alarmed = 2;

}

void sig_handler2( int signum ) {

*alarmed = 3;

}

int main( ) {

char stringA[40] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabc\0";

char stringB[40];

bzero( stringB, 40 );

strncpy( stringB, stringA, 40 );

bzero( stringA, 40 );

printf( "%s\n", stringA );

printf( "%s\n", stringB );

void* mem1 = malloc( 1024 );

void* mem2 = malloc( 1024 );

void* mem3 = malloc( 8192 );

void* mem4 = malloc( 4096 );

void* mem5 = malloc( 512 );

void* mem6 = malloc( 1024 );

void* mem7 = malloc( 512 );

free( mem6 );

free( mem5 );

free( mem1 );

free( mem7 );

free( mem2 );

void* mem8 = malloc( 4096 );

free( mem4 );

free( mem3 );

free( mem8 );

alarmed = (int *)malloc( 4 );

*alarmed = 1;

printf( "%d\n", *alarmed);

signal( SIGALRM, sig_handler1 );

alarm( 2 );

while ( *alarmed != 2 ) {

void* mem9 = malloc( 4 );

free( mem9 );

}

printf( "%d\n", *alarmed);

signal( SIGALRM, sig_handler2 );

alarm( 3 );

while ( *alarmed != 3 ) {

void* mem9 = malloc( 4 );

free( mem9 );

}

printf( "%d\n", *alarmed);

return 0;

}

This driver program repeats allocating and deallocating memory space and thereafter sets the sig_handler1( ) function to be called upon receiving the first timer interrupt (in 2 seconds) and sig_ahndler2( ) function to be called upon the second timer interrupt (in 3 seconds).

3.  System Overview and Execution Sequence

3.1.  Memory overview

This project maps all code to 0x0000.0000 – 0x1FFF.FFFF in the ARM’s usual ROM space (as the Keil C compiler/ARM assembler does) and defines a heap space; user and SVC stacks; memory control block (MCB) to manage the heap space; and all the SVC-related parameters over 0x2000.1000 – 0x2000.7FFF in the ARM’s usual SRAM space. See table 2.

Since we compiledriver.c together with our assembly programs, the Keil C compiler automatically reserves driver.c-related global data to some space within 0x2000.0000 – 0x2000.0FFF, which makes it difficult for us to start Master Stack Pointer (MSP) exactly at 0x2000.6000 toward to the lower address as well as to start  Process  Stack  Pointer  (PSP)  at  0x2000.5800.  So,  it’s  sufficient  to  map  MSP  and  PSP  around 0x2000.6000 and 0x2000.5800 respectively. For the purpose of this memory allocation, you should declare the space as shown in listing 2:

Listing 2: The memory space definition in Thumb-2

Heap_Size EQU     0x00005000

AREA HEAP, NOINIT, READWRITE, ALIGN=3

heap_base

Heap_Mem SPACE   Heap_Size

heap_limit

Handler_Stack_Size EQU 0x00000800

Thread_Stack_Size EQU 0x00000800

AREA STACK, NOINIT, READWRITE, ALIGN=3

Thread_Stack_Mem SPACE Thread_Stack_Size

initial_user_sp

Handler_Stack_Mem SPACE Handler_Stack_Size

initial_sp

SVC_Handler must invoke _systemcall_table_jump in svc.s. This in turn means you must prepare the svc.s file to implement _systemcall_table_jump. This function initializes the system call table in _systemcall_table_init as shown in Table 4:

Each table entry records the routine to jump. For this purpose, svc.s needs to import the addresses of these routines, using the code snippet shown in listing 5:

Listing 5: Entry points to kernel functions imported in svc.s IMPORT _kfree

IMPORT _kalloc

IMPORT _signal_handler

IMPORT _timer_start

When called from SVC_Handler, _system_call_table_jump checks R7, (i.e., the system call#) and refers to the corresponding jump table entry, and invokes the actual routine. The merit of using svc.c is to minimize your modifications onto startup_TM4C129.s.

(3) Interrupts: This final project only handles SysTick interrupts. The SysTick timer gets started with _timer_start that was invoked when main( ) calls alarm( ). Note that SysTick timer can countdown up to 1 second. Therefore, if main( ) calls alarm( 2 ) or alarm( 3 ), you’ll get a SysTick interrupts at  least  twice  or  three  times.  Upon  receiving   a  SysTick  interrupt,  the   control  jumps  to SysTick_Handler in startup_TM4C129.s. The handler routine will invoke _timer_update in timer.s to decrement the count provided by alarm( ), to check if the count reached 0, and if so to stop the timer as well as invoke func specified by signal( SIG_ALRM, func ).

3.3. Structure of your library implementation

The software components you need for this final project are summarized in table 5.

32-KB buddies, CL and CR. One of these buddies is used to satisfy the 21-KB request. This scheme is illustrated in Figure 10.26, where CL is the segment allocated to the 21-KB request.

An advantage of the buddy system is how quickly adjacent buddies can be combined to form larger segments using a technique known as coalescing. In Figure  10.26, for example, when the kernel releases the CLunit it was allocated, the system can coalesce CL and CR into a 64-KB segment. This segment, BL, can in turn be coalesced with its buddy BR to form a 128-KB segment. Ultimately, we can end up with the original 256-KB segment.

The obvious drawback to the buddy system is that rounding up to the next highest power of 2 is very likely to cause fragmentation within allocated segments. For example, a 33-KB request can only be satisfied with a 64-KB segment. In fact, we cannot guarantee that less than 50 percent of the allocated unit will be wasted due to internal fragmentation. In the following section, we explore a memory allocation scheme where no space is lost due to fragmentation.

4.2. Implementation over 0x20001000 - 0x20004FFF

As the memory range we use is 0x20001000 – 0x20004FFF, the entire contiguous size is 16KB. This space will be recursively divided into 2 subspaces of 8KB, each further divided into 2 pieces of 4KB, all the way to 32B. Therefore, one extreme allocates 16KB entirely at once, whereas the other extreme allocates 512 different spaces, each with 32 bytes. To address this finest case, (i.e., handling 512 spaces), we allocate a memory control block (MCB) of 512 entries, each with 2 bytes, in the 1KB space over 10x20006800 – 0x20006BFF. Each entry corresponds to a different 32-byte heap space. For instance, let MCB entries are defined as

short mcb[512];

Then, mcb[0] points to the heaps space at 0x20001000, whereas mcb[511] corresponds to 0x20004FE0. However, each mcb[i] does not have to manage only 32 bytes. It can manage up to a contiguous 16KB space. Therefore, each mcb[i] has the size information of a heap space it is currently managing. The size can be 32 bytes to 16KB and thus be represented with 5 to16 bits, in other words with mcb[i]’s bits #15 - #4. We also use mcb[i]’s LSB, (i.e., bit #0) to indicate if the given heap space is available (= 0) or in use (= 1). Table 6 shows each mcb[i]’sbit usage:

Figure 2: Recursive _ralloc/_rfree calls, each updating mcb entries

4.4. Test Scenario

Looking back to listing 1. “driver.c”, you are supposed to verify your Thumb-2 implementation of malloc( ) and free( ) with repetitive system call invocations that allocate/deallocate mem1 – mem8 spaces. Figure 2 illustrateshow the heap space is allocated and deallocated when you run driver.c. Orange indicates allocated spaces and green means de-allocated spaces.

Figure 2: Test scenario and memory allocation

5.  Signal and Alarm

The time management you will implement in your final project includes signal( sig, *func ) and alarm( seconds ). The parameters *func and seconds should be memorized in memory address at 0x20007B84 and 0x20007B80, as shown in table 7.

Table 7: Signal/alarm parameters to be stored in memory

Memory address	Parameters to store
0x2000.7B84	*func
0x2000.7B80	seconds

5.1. SysTick Initialization

The ARM system timer, SysTick’s description can be found at:

https://developer.arm.com/documentation/dui0552/a/cortex-m3-peripherals/system-timer--systick

Table 8 is acopy of Table 4.32. System timer register summary on that URL. Among four SysTick registers, you will use the first three registers: (1) SysTick Control and Status Register, (2) SysTick Relaod Value Register, and (3) SysTick Current Value Register.

Table 8: A copy from Cortex-M3 Devices Generic User Guide URL’s Table 4.32.

Please click each register’s hyperlink from table 4.32 to understand how the SysTick registers work.

For initialization in _timer_init,

(1) Make sure to stop SysTick:

Set SYST_CSR’s Bit 2 (CLK_SRC) = 1, Bit 1 (INT_EN) = 0, Bit 0 (ENABLE) = 0 (2) Load the maximum value to SYST_RVR:

The value should be 0x00FFFFFF which means MAX Value = 1/16MHz * 16M = 1 second

5.2. Signal

The signal( sig, *func ) function assumes only SIG_ALRM as the sig argument, while it accepts any address of *func (Keil C compiler automatically maps to memory). These sig and *funcarguments must be relayed from signal(sig, *func) all the way to _signal_handler in timer.s as keeping sig in R0 and *func in R1 respectively (based on APCS, see table 3). If R0 is SIG_ALRM, (i.e., 14), save it in memory address at 0x20007B84. Return the previous value of 0x2007B84 to main( ) through R0.

5.3. Alarm

The alarm( seconds ) function relays this seconds argument in R0 from main( ) all the way to _timer_start in timer.s. Retrieve the previous value at 0x20007B80 that is recognized as the previous time valuve and returned to main( ) through R0, save the new seconds value to 0x20007B80, and start the SysTick timer.

(1) Retrieve the seconds parameter from memory address 0x20007B80, which is the previous time value and should be returned to main( ).

(2)  Save anew seconds parameter from alarm( ) to memory address 0x20007B80. (3) Enable SysTick:

Set SYST_CSR’s Bit 2 (CLK_SRC) = 1, Bit 1 (INT_EN) = 1, Bit 0 (ENABLE) = 1 (4)  Clear SYST_CVR:

Set 0x00000000 in SYST_CVR.

5.4. SysTick Interrupt

A SysTick interrupt is caught at SysTick_Handler in startup_TM4C129.s. It is relayed to _timer_update in timer.s

This is the same as HW7-Q4.

The timer_update( ) function reads the value at address 0x20007B80, decrements the value by 1 (second), checks the value, branches to _timer_update_done if the value hasn’t reached 0, otherwise it needs to stop the timer and to invoke a user function whose address is maintained in 0x20007B84. To stop the timer, write “Bit 2 (CLK_SRC) = 1, Bit 1 (INT_EN) = 0, Bit 0 (ENABLE) = 0” to SYST_CSR. (Don’t forget to save back a decremented value into 0x20007B80.)