ported memaccess

Tests/isa/Cprograms/benchmark/glibc/build.sh

@@ -0,0 +1,45 @@
+scp ../../encoding.h home-1:/home/akilan/
+scp ../../entry.S home-1:/home/akilan/
+scp ../../link.ld home-1:/home/akilan/
+scp ../../riscv_test_p.h home-1:/home/akilan/
+scp ../../riscv_test.h home-1:/home/akilan/
+scp ../../string.c home-1:/home/akilan/
+scp ../../vm.c home-1:/home/akilan/
+scp ../../test.S home-1:/home/akilan/
+scp ../../test_macros.h home-1:/home/akilan/
+scp ../../malloc.c home-1:/home/akilan/
+# scp ../../test.c home-1:/home/akilan/
+scp glibc.c home-1:/home/akilan/
+
+# GCC compile
+# ssh home-1 'cd /home/akilan/ && export PATH=/opt/riscv/bin:$PATH && riscv64-unknown-elf-gcc -DENTROPY=0xf21e02b -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -mabi=lp64 -T link.ld vm.c string.c entry.S test.S -o testC'
+
+# Clang compile (architecture Regular RISCV)
+ssh home-1 'clang --target=riscv64-unknown-elf -DENTROPY=0xf21e02b -DDEFINE_MALLOC -DDEFINE_FREE --gcc-toolchain=/opt/riscv -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -fno-builtin-malloc -mabi=lp64 -T link.ld vm.c string.c malloc.c entry.S test.S glibc.c -o testC'
+
+# Clang using the cheri clang compiler
+# ssh home-1 'cd cheri/output/sdk/bin/ && ./clang --target=riscv64-unknown-freebsd -DENTROPY=0xf21e02b --sysroot=cheribsd-riscv64-for-purecap-rootfs.cfg -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -march=rv64imafdcxcheri -mabi=lp64d -T link.ld vm.c string.c entry.S test.S -o testC'
+
+scp home-1:/home/akilan/testC ../../../
+
+# scp home-1:/home/akilan/cheri/output/sdk/bin/testC .
+
+# riscv64-unknown-elf-gcc \
+#   -march=rv64imac \
+#   -mabi=lp64 \
+#   -nostartfiles \
+#   -fno-builtin \
+#   -T link.ld \
+#   entry.S vm.c string.c \
+
+# clang \
+#   --target=riscv64-unknown-elf \
+#   -march=rv64imac \
+#   -mabi=lp64 \
+#   -nostdlib \
+#   -nostartfiles \
+#   -fuse-ld=lld \
+#   -T link.ld \
+#   entry.S vm.c string.c \
+#   -I. \
+#   -o output.elf%

Tests/isa/Cprograms/benchmark/glibc/glibc.c

@@ -0,0 +1,229 @@
+/* Benchmark malloc and free functions.
+   Copyright (C) 2019-2021 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+// modified by Daan Leijen to fit the bench suite and add lifo/fifo free order.
+
+// #include <pthread.h>
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <sys/resource.h>
+// #include "malloc.h"
+
+// #include <cheriintrin.h>
+#include <stdint.h>
+#include <stddef.h>
+
+// #define malloc      MALLOCCHERI
+// #define free        FREECHERI
+
+// #include "bench-timing.h"
+// #include "json-lib.h"
+
+// void free(void * __capability ptr);
+// void * __capability malloc(size_t size);
+
+void* malloc(size_t size);
+void free(void *ptr);
+
+/* Benchmark the malloc/free performance of a varying number of blocks of a
+   given size.  This enables performance tracking of the t-cache and fastbins.
+   It tests 3 different scenarios: single-threaded using main arena,
+   multi-threaded using thread-arena, and main arena with SINGLE_THREAD_P
+   false.  */
+
+// source: https://github.com/daanx/mimalloc-bench/blob/master/bench/glibc-bench/bench-malloc-thread.c
+
+#define NUM_ITERS 20
+#define NUM_ALLOCS 4
+#define MAX_ALLOCS 1600
+
+// Daan: disable timing
+typedef long timing_t;
+#define TIMING_NOW(s) 
+#define TIMING_DIFF(e,start,stop)
+
+
+typedef struct
+{
+  size_t iters;
+  size_t size;
+  int n;
+  timing_t elapsed;
+} malloc_args;
+
+static void
+do_benchmark(malloc_args *args, char **arr)
+{
+  // timing_t start, stop;
+  size_t iters = args->iters;
+  size_t size = args->size;
+  int n = args->n;
+
+//   TIMING_NOW (start);
+
+  for (int j = 0; j < iters; j++)
+    {
+      for (int i = 0; i < n; i++) {
+        arr[i] = malloc (size);
+        for(int g = 0; g < size; g++) { arr[i][g] =(char)g; }
+      }
+
+      // free half in fifo order
+      for (int i = 0; i < n/2; i++) {
+	        free (arr[i]);
+          arr[i] = NULL;  
+      }
+    
+      // and the other half in lifo order
+      for(int i = n-1; i >= n/2; i--) {
+          free(arr[i]);
+          arr[i] = NULL;
+      }
+  }      
+
+//   TIMING_NOW (stop);
+
+//   TIMING_DIFF (args->elapsed, start, stop);
+}
+
+static malloc_args tests[3][NUM_ALLOCS];
+static int allocs[NUM_ALLOCS] = { 25, 100, 400, MAX_ALLOCS };
+
+// static void *
+// thread_test (void *p)
+// {
+//   char **arr = (char**)p;
+
+//   /* Run benchmark multi-threaded.  */
+//   for (int i = 0; i < NUM_ALLOCS; i++)
+//     do_benchmark (&tests[2][i], arr);
+
+//   return p;
+// }
+
+void
+bench (unsigned long size)
+{
+  size_t iters = NUM_ITERS;
+  char**arr = (char**)malloc (MAX_ALLOCS * sizeof (void*));
+  //char * __capability * __capability arr = malloc(MAX_ALLOCS * sizeof(char * __capability));
+
+  for (int t = 0; t < 3; t++)
+    for (int i = 0; i < NUM_ALLOCS; i++)
+      {
+	tests[t][i].n = allocs[i];
+	tests[t][i].size = size;
+	tests[t][i].iters = iters / allocs[i];
+
+	/* Do a quick warmup run.  */
+	if (t == 0)
+	  do_benchmark (&tests[0][i], arr);
+      }
+
+  /* Run benchmark single threaded in main_arena.  */
+  for (int i = 0; i < NUM_ALLOCS; i++)
+    do_benchmark (&tests[0][i], arr);
+
+  /* Run benchmark in a thread_arena.  */
+//   pthread_t t;
+//   pthread_create (&t, NULL, thread_test, (void*)arr);
+//   pthread_join (t, NULL);
+
+  /* Repeat benchmark in main_arena with SINGLE_THREAD_P == false.  */
+  // for (int i = 0; i < NUM_ALLOCS; i++)
+  //   do_benchmark (&tests[1][i], arr);
+
+  free (arr);
+  arr = NULL;
+
+  /*
+  json_ctx_t json_ctx;
+
+  json_init (&json_ctx, 0, stdout);
+
+  json_document_begin (&json_ctx);
+
+  json_attr_string (&json_ctx, "timing_type", TIMING_TYPE);
+
+  json_attr_object_begin (&json_ctx, "functions");
+
+  json_attr_object_begin (&json_ctx, "malloc");
+
+  char s[100];
+  double iters2 = iters;
+
+  json_attr_object_begin (&json_ctx, "");
+  json_attr_double (&json_ctx, "malloc_block_size", size);
+
+  struct rusage usage;
+  getrusage (RUSAGE_SELF, &usage);
+  json_attr_double (&json_ctx, "max_rss", usage.ru_maxrss);
+
+  for (int i = 0; i < NUM_ALLOCS; i++)
+    {
+      sprintf (s, "main_arena_st_allocs_%04d_time", allocs[i]);
+      json_attr_double (&json_ctx, s, tests[0][i].elapsed / iters2);
+    }
+
+  for (int i = 0; i < NUM_ALLOCS; i++)
+    {
+      sprintf (s, "main_arena_mt_allocs_%04d_time", allocs[i]);
+      json_attr_double (&json_ctx, s, tests[1][i].elapsed / iters2);
+    }
+
+  for (int i = 0; i < NUM_ALLOCS; i++)
+    {
+      sprintf (s, "thread_arena__allocs_%04d_time", allocs[i]);
+      json_attr_double (&json_ctx, s, tests[2][i].elapsed / iters2);
+    }
+
+  json_attr_object_end (&json_ctx);
+
+  json_attr_object_end (&json_ctx);
+
+  json_attr_object_end (&json_ctx);
+
+  json_document_end (&json_ctx);
+  */
+}
+
+// static void usage (const char *name)
+// {
+//   fprintf (stderr, "%s: <alloc_size>\n", name);
+//   exit (1);
+// }
+
+int main (void)
+{
+//   INITREGULARALLOC();
+  long size = 3;
+//   if (argc == 2)
+//     size = strtol (argv[1], NULL, 0);
+
+//   if (argc > 2 || size <= 0)
+//     usage (argv[0]);
+
+  // bench (size);
+  // bench (2*size);
+  // bench (4*size);
+  // bench (8*size);
+  // bench (16*size);
+  // bench (32*size); 
+
+  return 0;
+}

Tests/isa/Cprograms/benchmark/memaccess/build.sh

@@ -0,0 +1,45 @@
+scp ../../encoding.h home-1:/home/akilan/
+scp ../../entry.S home-1:/home/akilan/
+scp ../../link.ld home-1:/home/akilan/
+scp ../../riscv_test_p.h home-1:/home/akilan/
+scp ../../riscv_test.h home-1:/home/akilan/
+scp ../../string.c home-1:/home/akilan/
+scp ../../vm.c home-1:/home/akilan/
+scp ../../test.S home-1:/home/akilan/
+scp ../../test_macros.h home-1:/home/akilan/
+scp ../../malloc.c home-1:/home/akilan/
+# scp ../../test.c home-1:/home/akilan/
+scp memaccess.c home-1:/home/akilan/
+
+# GCC compile
+# ssh home-1 'cd /home/akilan/ && export PATH=/opt/riscv/bin:$PATH && riscv64-unknown-elf-gcc -DENTROPY=0xf21e02b -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -mabi=lp64 -T link.ld vm.c string.c entry.S test.S -o testC'
+
+# Clang compile (architecture Regular RISCV)
+ssh home-1 'clang --target=riscv64-unknown-elf -DENTROPY=0xf21e02b -DDEFINE_MALLOC -DDEFINE_FREE --gcc-toolchain=/opt/riscv -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -fno-builtin-malloc -mabi=lp64 -T link.ld vm.c string.c malloc.c entry.S test.S memaccess.c -o testC'
+
+# Clang using the cheri clang compiler
+# ssh home-1 'cd cheri/output/sdk/bin/ && ./clang --target=riscv64-unknown-freebsd -DENTROPY=0xf21e02b --sysroot=cheribsd-riscv64-for-purecap-rootfs.cfg -mcmodel=medany -nostdlib -nostartfiles -ffreestanding -fno-builtin -march=rv64imafdcxcheri -mabi=lp64d -T link.ld vm.c string.c entry.S test.S -o testC'
+
+scp home-1:/home/akilan/testC ../../../
+
+# scp home-1:/home/akilan/cheri/output/sdk/bin/testC .
+
+# riscv64-unknown-elf-gcc \
+#   -march=rv64imac \
+#   -mabi=lp64 \
+#   -nostartfiles \
+#   -fno-builtin \
+#   -T link.ld \
+#   entry.S vm.c string.c \
+
+# clang \
+#   --target=riscv64-unknown-elf \
+#   -march=rv64imac \
+#   -mabi=lp64 \
+#   -nostdlib \
+#   -nostartfiles \
+#   -fuse-ld=lld \
+#   -T link.ld \
+#   entry.S vm.c string.c \
+#   -I. \
+#   -o output.elf%

Tests/isa/Cprograms/benchmark/memaccess/memaccess.c

@@ -0,0 +1,364 @@
+/*
+memaccesstest.c
+Author Alex Bordei at bigstep
+All rights reserved. 
+*/
+
+// source: https://github.com/bigstepinc/memaccesstest/tree/master
+
+// #include <stdio.h>
+// #include <cheriintrin.h>
+#include <stddef.h>
+#include <stdint.h>
+// #include <stdlib.h>
+// #include <pthread.h>
+// #include "config.h"
+
+// #ifndef __MACH__
+// #include <time.h>
+// #else
+// #include <mach/mach_time.h>
+// #endif
+
+// #include "malloc.h"
+
+// #define malloc      MALLOCCHERI
+// #define free        FREECHERI
+
+#define NPAD 7
+#define MIN_WSS sizeof(struct l)
+#define MAX_WSS 10
+
+void free(void *ptr);
+void *malloc(size_t size);
+
+
+
+// struct l{
+// 	struct l *n;
+// 	struct l *p;
+// 	long int pad[NPAD-1];
+
+// };
+
+struct l{
+    struct l *n;
+    struct l *p;
+    long int pad[NPAD-1];
+};
+
+// uint64_t rand64()
+// {
+// 	// Combin 4 parts of low 16-bit of each rand()
+// 	uint64_t R0 = (uint64_t)random() << 48;
+// 	uint64_t R1 = (uint64_t)random() << 48 >> 16;
+// 	uint64_t R2 = (uint64_t)random() << 48 >> 32;
+// 	uint64_t R3 = (uint64_t)random() << 48 >> 48;
+// 	return R0 | R1 | R2 | R3;
+// };
+
+#ifdef DEBUG
+// void print_ll_lin(struct l *root,unsigned long working_set_size)
+// {
+// 	struct l *current=root->n;
+// 	unsigned long count;
+// 	printf("0");
+// 	count=0;
+// 	while(current!=root)
+// 	{
+// 		// printf("->%ld",current-root);
+// 		current=current->n;
+// 		count++;
+// 		if(count>working_set_size/sizeof(struct l))
+// 		{
+// 			// printf("Error:cycle!");
+// 			break;
+// 		}
+			
+// 	}	
+// 	// printf("\n");
+// }
+// void print_ll_lin_back(struct l *root,unsigned long working_set_size)
+// {
+// 	struct l *current=root->p;
+// 	unsigned long count;
+// 	printf("0");
+// 	count=0;
+// 	while(current!=root)
+// 	{
+// 		// printf("->%ld",current-root);
+// 		current=current->p;
+// 		count++;
+// 		if(count>working_set_size/sizeof(struct l))
+// 		{
+// 			// printf("Error:cycle!");
+// 			break;
+// 		}
+			
+// 	}	
+// 	printf("\n");
+// }
+// void print_ll(struct l *root,unsigned long working_set_size)
+// {
+// 	unsigned long i;
+// 	for(i=0;i<(working_set_size/sizeof(struct l));i++)
+// 		printf("DEBUG: %ld<-%ld->%ld\n",(root+i)->p-root,i,((root+i)->n)-root);		
+// 	printf("DEBUG ");
+// 	print_ll_lin(root, working_set_size);
+// 	printf("DEBUG ");
+// 	print_ll_lin_back(root, working_set_size);
+
+// }
+#endif
+
+// void build_sequencial_ll(struct l * root, long working_set_size)
+void build_sequencial_ll(struct l *root, long working_set_size)
+{
+
+		unsigned long i;
+
+		struct l *current;
+
+
+		for(i=0;i<(working_set_size/sizeof(struct l));i++)
+		{
+			current=root+i;	
+			if(i==(working_set_size/sizeof(struct l)-1))
+				current->n=root;
+			else
+				current->n=current+1;
+			if(i==0)
+				current->p=root+working_set_size/sizeof(struct l)-1;
+			else
+				current->p=current-1;
+		} 
+}
+
+// void build_random_ll(struct l *root, long working_set_size)
+// {
+
+// 		unsigned long i;
+
+
+// 		struct l *a;
+// 		struct l *b;
+// 		struct l *oldan;
+// 		struct l *oldbn;
+// 		struct l *oldap;
+// 		struct l *oldbp;
+
+// 		unsigned long rnd;
+// 		unsigned long tries;
+
+// 		build_sequencial_ll(root, working_set_size);
+
+// 		//construct the array of elements 
+// 		//link the list to the next element in the array
+
+// 		for(i=1;i<(working_set_size/sizeof(struct l)-1);i++)
+// 		{
+
+// 			a=(root+i);
+// 			b=a;
+// 			tries=5;	
+// 			while((b==a || b==root) && tries)
+// 			{
+// 				rnd=rand64() % (working_set_size/sizeof(struct l)-1);	
+// 				b=root+rnd;
+// 				tries--;
+// 			}
+// 			if(!tries)
+// 				continue;
+
+			
+// 			oldan=a->n; //a->n is lost along the way
+// 			oldbn=b->n;  //b->n is lost along the way
+// 			oldap=a->p; //a->p is lost along the way
+// 			oldbp=b->p;  //b->p is lost along the way
+
+// 			a->p->n=b;
+// 			b->p->n=a;
+
+// 			if(b!=oldan)
+// 			{
+// 				b->n=oldan;    		
+// 				oldan->p=b;
+// 			}
+// 			else
+// 			{
+// 				b->n=a;
+// 				a->p=b;
+// 			}
+
+// 			if(a!=oldbn)
+// 			{
+// 				a->n=oldbn;		
+// 				oldbn->p=a;
+// 			}
+// 			else
+// 			{
+// 				a->n=b;
+// 				b->p=a;
+// 			}
+
+// 			if(b!=oldap)
+// 				b->p=oldap; 
+// 			else
+// 				b->p=a;
+
+// 			if(a!=oldbp)
+// 				a->p=oldbp;
+// 			else
+// 				a->p=b;
+
+
+// #ifdef DEBUG
+// 			printf("DEBUG: Round i=%ld\n",i);		
+// 			printf("DEBUG: A=%ld B=%ld\n",a-root,b-root);
+// 			print_ll(root, working_set_size);
+// #endif
+// 		} 
+
+// }
+
+
+
+struct thread_start_data
+{
+	struct l *root;
+	unsigned long working_set_size;
+	int thread_index;		
+};
+
+void * walk(void *param)
+{
+
+		struct thread_start_data *data=param;
+		unsigned long start,end;
+
+
+		struct l *root=data->root;	
+		// struct l* current=root->n;		
+        struct l *current = root->n;  	
+
+		// #ifdef __MACH__
+		// start=mach_absolute_time();
+		// #else
+		// struct timespec ts;
+		// clock_gettime(CLOCK_MONOTONIC_RAW,&ts);
+		// start=ts.tv_nsec; 
+		// #endif
+	
+
+		/////////////////////////////////////
+		//traverse the linked list
+		
+		while(current!=root)	
+		{
+// #ifdef ADDTEST
+// 			current->pad[0]+=current->n->pad[0];
+// #endif
+
+// #ifdef INCTEST
+// 			current->pad[0]++;
+// #endif
+			current=current->n;	
+		}
+
+			
+		/////////////////////////////////////
+// #ifdef __MACH__
+// 		end=mach_absolute_time();
+// #else
+// 		clock_gettime(CLOCK_MONOTONIC_RAW,&ts);
+// 		end=ts.tv_nsec; 
+// #endif
+	
+
+		// printf("%d,%ld,%ld,%ld\n",data->thread_index,data->working_set_size, end-start, data->working_set_size/sizeof(struct l));
+
+		// free(data);
+		return NULL;
+}
+
+int main(void)
+{
+// clock_t tic = clock();
+// INITREGULARALLOC();
+//#ifdef DEBUG
+	// printf("DEBUG:sizeof(struct l)=%ld\n",sizeof(struct l));
+// #endif
+	struct l *root;
+	unsigned long working_set_size;
+	int i;
+	// struct thread_start_data *tdata;
+    struct thread_start_data *tdata;
+
+
+	// pthread_t threads[NTHREADS];
+
+	root=malloc(MAX_WSS/sizeof(struct l) * sizeof(struct l));	
+		
+	for(working_set_size=MIN_WSS;working_set_size<MAX_WSS;working_set_size=working_set_size<<1)
+	{
+
+// #ifdef DEBUG
+// 		printf("DEBUG:Working set size=%ld elements=%ld\n",working_set_size,working_set_size/sizeof(struct l));
+// #endif
+// clock_t toc = clock();
+// printf("Elapsed build get here before ll: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);
+// #ifdef RANDOM_LIST
+// 		build_random_ll(root, working_set_size);
+// #else
+	// clock_t tic1 = clock();
+	build_sequencial_ll(root, working_set_size);
+	// build_sequencial_ll(root, working_set_size);
+	// clock_t toc1 = clock();
+	// printf("Elapsed build ll: %f seconds\n", (double)(toc1 - tic1) / CLOCKS_PER_SEC);
+// #endif
+
+// #if NTHREADS>0			
+// 		for(i=0;i<NTHREADS;i++)
+// 		{
+// 			tdata= malloc(sizeof(struct thread_start_data));
+// 			tdata->thread_index=i;
+// 			tdata->root=root;
+// 			tdata->working_set_size=working_set_size;
+// 			pthread_create(&threads[i], NULL, walk, (void*) tdata);
+// 		}
+
+// 		for(i=0;i<NTHREADS;i++)
+// 			pthread_join(threads[i],NULL);					
+// #else
+		tdata = malloc(sizeof(struct thread_start_data));
+		tdata->thread_index=0;
+		tdata->root=root;
+		tdata->working_set_size=working_set_size;
+		// clock_t tic2 = clock();
+		for (int i = 0; i < 64; i++) {
+			walk(tdata);	
+		}
+
+        // tdata = malloc(sizeof(struct thread_start_data));
+		// tdata->thread_index=0;
+		// tdata->root=root;
+		// tdata->working_set_size=working_set_size;
+		// // clock_t tic2 = clock();
+		// for (int i = 0; i < 64; i++) {
+		// 	walk(tdata);	
+		// }
+        
+		// clock_t toc2 = clock();
+		// printf("Elapsed build walk: %f seconds\n", (double)(toc2 - tic2) / CLOCKS_PER_SEC);
+// #endif
+	}
+
+	// printf("-----------------------------------------------");
+
+
+	free(root);	
+    root = NULL;
+
+    return 0;
+
+}

builds/RV64ACDFIMSUxCHERI_Toooba_bluesim/.gitignore

@@ -0,0 +1 @@
+*.txt