Index: /soft/giet_vm/Makefile
===================================================================
--- /soft/giet_vm/Makefile (revision 255)
+++ /soft/giet_vm/Makefile (revision 256)
@@ -50,4 +50,7 @@
build/libs/malloc.o
+SORT_OBJS = build/sort/main.o \
+ build/libs/stdio.o \
+ build/libs/barrier.o
CFLAGS = -Wall -ffreestanding -mno-gpopt -mips32
@@ -66,4 +69,5 @@
build/gameoflife/gameoflife.elf \
build/dhrystone/dhrystone.elf \
+ build/sort/sort.elf \
$(MAKE) -C memo
@@ -150,4 +154,12 @@
$(CC) $(INCLUDE) $(CFLAGS) -c -o $@ $<
+### sort compilation
+build/sort/sort.elf: $(SORT_OBJS) sort/sort.ld
+ $(LD) -o $@ -T sort/sort.ld $(SORT_OBJS)
+ $(DU) -D $@ > $@.txt
+
+build/sort/main.o: sort/main.c
+ $(CC) $(INCLUDE) $(CFLAGS) -O3 -c -o $@ $<
+
### libs compilation
build/libs/utils.o: libs/utils.c giet_config.h
Index: /soft/giet_vm/mappings/4c_2p_40_sort.xml
===================================================================
--- /soft/giet_vm/mappings/4c_2p_40_sort.xml (revision 256)
+++ /soft/giet_vm/mappings/4c_2p_40_sort.xml (revision 256)
@@ -0,0 +1,264 @@
+
+
+
+
+*** This first section describes an instance of the "tsar_generic_xbar" architecture
+*** with 4 clusters, 2 processor per cluster and 40 bits physical address.
+
+
+
+
+
+
+
+
+*** Boot ROM and non replicated peripherals
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** segments used by the boot code / A[31:28] = 0xB / Identity mapping
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** Non replicated peripherals / A[31:28] = 0xB / Identity mapping
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** segments used by the kernel / A[31:28] = 0x8
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** Replicated ICUS / A[31:28] = 0xE / Increment = 0x10000
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** Replicated DMAs / A[31:28] = 0xD / Increment = 0x10000
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*** Replicated schedulers / A[31:28] = 0xF / Increment = 0x10000
+
+
+
+
+
+
+
+
+
+
+
+
+
+***
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Index: /soft/giet_vm/sort/main.c
===================================================================
--- /soft/giet_vm/sort/main.c (revision 256)
+++ /soft/giet_vm/sort/main.c (revision 256)
@@ -0,0 +1,242 @@
+//=================================================================================================
+// File : main.c
+//
+// Date : 11/2013
+//
+// Author : Cesar Fuguet Tortolero
+// :
+//
+// Description: Sort application using the GIET-VM OS.
+// This application uses the barrier routines to apply a sort algorithm
+// in several stages.
+//=================================================================================================
+
+#include "stdio.h"
+#include "hard_config.h"
+#include "barrier.h"
+
+#define NPROCS 8
+#define ARRAY_LENGTH (NPROCS * 50)
+#define IPP (ARRAY_LENGTH / NPROCS) // ITEMS PER PROCESSOR
+
+// Other processors than 0 display algorithm state
+#define VERBOSE 1
+
+#if (VERBOSE == 1)
+#define printf(...) giet_tty_printf(__VA_ARGS__)
+#define puts(...) giet_tty_puts(__VA_ARGS__)
+#else
+#define printf(...)
+#define puts(...)
+#endif
+
+#define exit giet_exit
+#define procid giet_procid
+#define rand giet_rand
+
+#define task0_printf(...) if(procid() == 0) giet_tty_printf(__VA_ARGS__)
+
+int array0[ARRAY_LENGTH];
+int array1[ARRAY_LENGTH];
+
+volatile int init_ok = 0;
+
+void bubbleSort(
+ int * array,
+ unsigned int length,
+ unsigned int init_pos);
+
+void merge(
+ int * array,
+ int * result,
+ int length,
+ int init_pos_a,
+ int init_pos_b,
+ int init_pos_result);
+
+// this application support at most 256 processors
+// number of barriers = log2(NPROCS)
+giet_barrier_t barrier[8];
+
+__attribute__ ((constructor)) void sort()
+{
+ int proc_id = procid();
+ int * src_array;
+ int * dst_array;
+ int i;
+
+ /**************************************************************************/
+ /* Hello World */
+
+ task0_printf("Starting SORT application\n");
+
+ /**************************************************************************/
+ /* Array Inititialitatin */
+
+ for (i = IPP * proc_id; i < IPP * (proc_id + 1); i++)
+ {
+ array0[i] = rand();
+ }
+
+ /**************************************************************************/
+ /* Barriers Inititialitatin */
+
+ while((proc_id != 0) && (init_ok == 0));
+
+ if (proc_id == 0)
+ {
+ for (i = 0; i < __builtin_ctz(NPROCS); i++)
+ {
+ printf("Initializing barrier %d with %d\n", i, NPROCS >> i);
+ barrier_init(&barrier[i], NPROCS >> i);
+ }
+
+ asm volatile ("sync");
+ init_ok = 1;
+ }
+
+ asm volatile ("sync");
+ barrier_wait(&barrier[0]);
+
+ /**************************************************************************/
+ /* Parallel sorting of array pieces */
+
+ task0_printf("Stage 0: Processor Sorting...\n\r");
+ bubbleSort(array0, IPP, IPP * proc_id);
+ task0_printf("Finishing Stage 0...\n\r");
+
+ for (i = 0; i < __builtin_ctz(NPROCS); i++)
+ {
+ asm volatile ("sync");
+ barrier_wait(&barrier[i]);
+ task0_printf("Stage %d: Starting...\n\r", i+1);
+
+ if((proc_id % (2 << i)) != 0) exit();
+
+ if((i % 2) == 0)
+ {
+ src_array = &array0[0];
+ dst_array = &array1[0];
+ }
+ else
+ {
+ src_array = &array1[0];
+ dst_array = &array0[0];
+ }
+
+ merge(src_array, dst_array
+ , IPP << i
+ , IPP * proc_id
+ , IPP * (proc_id + (1 << i))
+ , IPP * proc_id
+ );
+
+ task0_printf("Finishing Stage %d...\n\r", i + 1);
+ }
+
+ int success;
+ int failure_index;
+
+ if(proc_id == 0)
+ {
+ success = 1;
+
+ for(i=0; i<(ARRAY_LENGTH-1); i++)
+ {
+ if(dst_array[i] > dst_array[i+1])
+ {
+
+ success = 0;
+ failure_index = i;
+ break;
+ }
+ }
+
+ if (success)
+ {
+ printf("Success!!\n\r");
+ }
+ else
+ {
+ printf("Failure!! Incorrect element: %d\n\r", failure_index);
+
+
+ for(i=0; i array[j + 1])
+ {
+ aux = array[j + 1];
+ array[j + 1] = array[j];
+ array[j] = aux;
+ }
+ }
+ }
+}
+
+void merge(
+ int * array,
+ int * result,
+ int length,
+ int init_pos_a,
+ int init_pos_b,
+ int init_pos_result)
+{
+ int i;
+ int j;
+ int k;
+
+ i = 0;
+ j = 0;
+ k = init_pos_result;
+
+ while((i < length) || (j < length))
+ {
+ if((i < length) && (j < length))
+ {
+ if(array[init_pos_a + i] < array[init_pos_b + j])
+ {
+ result[k++] = array[init_pos_a + i];
+ i++;
+ }
+ else
+ {
+ result[k++] = array[init_pos_b + j];
+ j++;
+ }
+ }
+ else if(i < length)
+ {
+ result[k++] = array[init_pos_a + i];
+ i++;
+ }
+ else
+ {
+ result[k++] = array[init_pos_b + j];
+ j++;
+ }
+ }
+}
+
+/* vim: tabstop=4 : shiftwidth=4 : expandtab
+*/
Index: /soft/giet_vm/sort/sort.ld
===================================================================
--- /soft/giet_vm/sort/sort.ld (revision 256)
+++ /soft/giet_vm/sort/sort.ld (revision 256)
@@ -0,0 +1,40 @@
+/****************************************************************************
+* Definition of the base address for all virtual segments
+*****************************************************************************/
+
+seg_data_base = 0x00800000;
+seg_code_base = 0x00400000;
+
+/***************************************************************************
+* Grouping sections into segments for code and data
+***************************************************************************/
+
+SECTIONS
+{
+ . = seg_code_base;
+ seg_code :
+ {
+ *(.text)
+ *(.text.*)
+ }
+ . = seg_data_base;
+ seg_data :
+ {
+ *(.ctors)
+ *(.rodata)
+ /* . = ALIGN(4); */
+ *(.rodata.*)
+ /* . = ALIGN(4); */
+ *(.data)
+ /* . = ALIGN(4); */
+ *(.lit8)
+ *(.lit4)
+ *(.sdata)
+ /* . = ALIGN(4); */
+ *(.bss)
+ *(COMMON)
+ *(.sbss)
+ *(.scommon)
+ }
+}
+