From f82ec2d3bb8d8a55c8b154eb0d70b17184b0384e Mon Sep 17 00:00:00 2001 From: Akilan Date: Thu, 7 Aug 2025 22:26:21 +0100 Subject: [PATCH] added huge allocator as shared object file --- .../allocator/allocator_shared_object_file.c | 302 ++++++++++++++++++ benchmarks/allocator/build.sh | 12 +- .../richards-benchmark/stddefines.h | 54 ++-- 3 files changed, 335 insertions(+), 33 deletions(-) create mode 100644 benchmarks/allocator/allocator_shared_object_file.c diff --git a/benchmarks/allocator/allocator_shared_object_file.c b/benchmarks/allocator/allocator_shared_object_file.c new file mode 100644 index 0000000..11bd3df --- /dev/null +++ b/benchmarks/allocator/allocator_shared_object_file.c @@ -0,0 +1,302 @@ +/* Copyright (c) 2007-2009, Stanford University +* All rights reserved. +* +* Redistribution and use in source and binary forms, with or without +* modification, are permitted provided that the following conditions are met: +* * Redistributions of source code must retain the above copyright +* notice, this list of conditions and the following disclaimer. +* * Redistributions in binary form must reproduce the above copyright +* notice, this list of conditions and the following disclaimer in the +* documentation and/or other materials provided with the distribution. +* * Neither the name of Stanford University nor the +* names of its contributors may be used to endorse or promote products +* derived from this software without specific prior written permission. +* +* THIS SOFTWARE IS PROVIDED BY STANFORD UNIVERSITY ``AS IS'' AND ANY +* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +* DISCLAIMED. IN NO EVENT SHALL STANFORD UNIVERSITY BE LIABLE FOR ANY +* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#ifndef STDDEFINES_H_ +#define STDDEFINES_H_ + +#include +#include +#include +#include +#include +#include +#include + + +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +#define MAXPAGESIZES 2 + + +//#define TIMING + +/* Debug printf */ +#define dprintf(...) fprintf(stdout, __VA_ARGS__) + +/* Wrapper to check for errors */ +#define CHECK_ERROR(a) \ + if (a) \ + { \ + perror("Error at line\n\t" #a "\nSystem Msg"); \ + assert ((a) == 0); \ + } + +// static inline void *MALLOC(size_t size) +// { +// void * temp = malloc(size); +// assert(temp); +// return temp; +// } + +// static inline void *CALLOC(size_t num, size_t size) +// { +// void * temp = calloc(num, size); +// assert(temp); +// return temp; +// } + +// static inline void *REALLOC(void *ptr, size_t size) +// { +// void * temp = realloc(ptr, size); +// assert(temp); +// return temp; +// } + +// static inline char *GETENV(char *envstr) +// { +// char *env = getenv(envstr); +// if (!env) return "0"; +// else return env; +// } + +#define GET_TIME(start, end, duration) \ + duration.tv_sec = (end.tv_sec - start.tv_sec); \ + if (end.tv_nsec >= start.tv_nsec) { \ + duration.tv_nsec = (end.tv_nsec - start.tv_nsec); \ + } \ + else { \ + duration.tv_nsec = (1000000000L - (start.tv_nsec - end.tv_nsec)); \ + duration.tv_sec--; \ + } \ + if (duration.tv_nsec >= 1000000000L) { \ + duration.tv_sec++; \ + duration.tv_nsec -= 1000000000L; \ + } + +static inline unsigned int time_diff ( + struct timeval *end, struct timeval *begin) +{ +#ifdef TIMING + uint64_t result; + + result = end->tv_sec - begin->tv_sec; + result *= 1000000; /* usec */ + result += end->tv_usec - begin->tv_usec; + + return result; +#else + return 0; +#endif +} + +static inline void get_time (struct timeval *t) +{ +#ifdef TIMING + gettimeofday (t, NULL); +#endif +} + +// Expirement work + +#define FILENAME "/dev/contigmem" + +static char *heap_start; +static char *heap; +static size_t HEAP_SIZE = 1024 * 1024 * 1024; + +void *ptr; +int MallocCounter = 0; + +size_t sizeUsed; + +// INITAlloc(void) { + +// size_t sz; +// // Pre Allocate 600 MB +// sz = 100000000; + +// int fd = open(FILENAME, O_RDWR, 0600); + +// if (fd < 0) { +// perror("open"); +// exit(EXIT_FAILURE); +// } + +// off_t offset = 0; // offset to seek to. + +// if (ftruncate(fd, sz) < 0) { +// perror("ftruncate"); +// close(fd); +// exit(EXIT_FAILURE); +// } + +// // ptr = mmap(NULL, sz, +// // PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,-1,0); + +// ptr = mmap(NULL, sz, +// PROT_READ|PROT_WRITE, MAP_SHARED,fd,0); + +// // Added error handling +// if(ptr == MAP_FAILED) +// { +// perror("mmap"); +// exit(EXIT_FAILURE); +// } + +// MallocCounter = (int)sz; + +// } + +// Quick malloc implementation with mmap +void* malloc(size_t sz) +{ + // If malloc is called for the first time then allocate huge page + if (MallocCounter == 0) { + INITREGULARALLOC(); + } + sz = __builtin_align_up(sz, _Alignof(max_align_t)); + + // printf("%d \n", sz); + // printf("%d Malloc counter\n", MallocCounter); + + MallocCounter -= sz; + void *ptrLink = &ptr[MallocCounter]; + ptrLink = cheri_setbounds(ptrLink, sz); + + return ptrLink; + +// if (heap + sz > heap_start + HEAP_SIZE) return NULL; +// heap += sz; +// return heap - sz; + +} + +// Quick cheri free implementation +void free(void *ptr) { + + // printf("free called \n"); + + // get bounds from + int len = cheri_getlen(ptr); + + // printf("free len %d \n", len); + + munmap(ptr, len); +} + +static int +pagesizes(size_t ps[MAXPAGESIZES]) +{ + int pscnt; + + pscnt = getpagesizes(ps, MAXPAGESIZES); + // ATF_REQUIRE_MSG(pscnt != -1, "getpagesizes failed; errno=%d", errno); + // ATF_REQUIRE_MSG(ps[0] != 0, "psind 0 is %zu", ps[0]); + // ATF_REQUIRE_MSG(pscnt <= MAXPAGESIZES, "invalid pscnt %d", pscnt); + // if (pscnt == 1){ + // printf("pscnt is 1"); + // } + + // atf_tc_skip("no large page support"); + return (pscnt); +} + +INITREGULARALLOC(void) { + size_t sz; + // Pre Allocate 400 MB + sz = 1073741824; + + int error, fd, pscnt, pn; + + size_t ps[MAXPAGESIZES]; + + size_t size[3]; + + pn = getpagesizes(size, 3); + printf("page size is [%d]", size[2]); + + pscnt = pagesizes(ps); + + fd = shm_create_largepage(SHM_ANON, O_CREAT | O_RDWR, 1, SHM_LARGEPAGE_ALLOC_DEFAULT, 0); + + if (fd < 0 && errno == ENOTTY) { + perror("sh_create_largepages"); + close(fd); + exit(EXIT_FAILURE); + } + // if (fd < 0) + // perror("no large page supported"); + // exit(EXIT_FAILURE); + // if (fd < 0 && errno == ENOTTY) + // atf_tc_skip("no large page support"); + // ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; errno=%d", errno); + + if (ftruncate(fd, sz) < 0) { + perror("ftruncate"); + close(fd); + exit(EXIT_FAILURE); + } + // if (error != 0 && errno == ENOMEM) + // /* + // * The test system might not have enough memory to accommodate + // * the request. + // */ + // atf_tc_skip("failed to allocate %zu-byte superpage", sz); + // ATF_REQUIRE_MSG(error == 0, "ftruncate failed; errno=%d", errno); + + ptr = mmap(NULL, sz, + PROT_READ|PROT_WRITE, MAP_SHARED,fd,0); + + // Added error handling + if(ptr == MAP_FAILED) + { + perror("mmap"); + exit(EXIT_FAILURE); + } + + MallocCounter = (int)sz; +} +// Standard Alloc +// void* MALLOCREGULAR(size_t sz) { + +// } + + +// void* CLEARALLOC(void) { +// / +// } + +#endif // STDDEFINES_H_ diff --git a/benchmarks/allocator/build.sh b/benchmarks/allocator/build.sh index 2135b22..d069ac0 100644 --- a/benchmarks/allocator/build.sh +++ b/benchmarks/allocator/build.sh @@ -1,7 +1,7 @@ -cc -g -Wall -Wextra -lstatic -Wno-unused-parameter -mabi=purecap-benchmark -c allocator.c -o alloc.o -ar rcs alloc.a alloc.o +cc -O3 -g -W -Wall -Wextra -Wno-unused-parameter -shared -fPIC allocator_shared_object_file.c -o hugepage_alloc.so +# ar rcs alloc.a alloc.o # cc -O3 -g -W -Wall -Wextra -Wno-unused-parameter -shared -fPIC -o alloc.so -cp alloc.o ../benchmarks/kmeans/ -cp alloc.a ../benchmarks/kmeans/ -cp alloc.o /home/akilan/Alloc-Test/cheri_malloc_blog -cp alloc.a /home/akilan/Alloc-Test/cheri_malloc_blog \ No newline at end of file +# cp alloc.o ../benchmarks/kmeans/ +# cp alloc.a ../benchmarks/kmeans/ +# cp alloc.o /home/akilan/Alloc-Test/cheri_malloc_blog +# cp alloc.a /home/akilan/Alloc-Test/cheri_malloc_blog \ No newline at end of file diff --git a/benchmarks/benchmarks/richards-benchmark/stddefines.h b/benchmarks/benchmarks/richards-benchmark/stddefines.h index 595bdcb..5690a9a 100644 --- a/benchmarks/benchmarks/richards-benchmark/stddefines.h +++ b/benchmarks/benchmarks/richards-benchmark/stddefines.h @@ -142,43 +142,43 @@ int MallocCounter; size_t sizeUsed; -INITAlloc(void) { +// INITAlloc(void) { - size_t sz; - // Pre Allocate 600 MB - sz = 100000000; +// size_t sz; +// // Pre Allocate 600 MB +// sz = 100000000; - int fd = open(FILENAME, O_RDWR, 0600); +// int fd = open(FILENAME, O_RDWR, 0600); - if (fd < 0) { - perror("open"); - exit(EXIT_FAILURE); - } +// if (fd < 0) { +// perror("open"); +// exit(EXIT_FAILURE); +// } - off_t offset = 0; // offset to seek to. +// off_t offset = 0; // offset to seek to. - if (ftruncate(fd, sz) < 0) { - perror("ftruncate"); - close(fd); - exit(EXIT_FAILURE); - } +// if (ftruncate(fd, sz) < 0) { +// perror("ftruncate"); +// close(fd); +// exit(EXIT_FAILURE); +// } - // ptr = mmap(NULL, sz, - // PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,-1,0); +// // ptr = mmap(NULL, sz, +// // PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,-1,0); - ptr = mmap(NULL, sz, - PROT_READ|PROT_WRITE, MAP_SHARED,fd,0); +// ptr = mmap(NULL, sz, +// PROT_READ|PROT_WRITE, MAP_SHARED,fd,0); - // Added error handling - if(ptr == MAP_FAILED) - { - perror("mmap"); - exit(EXIT_FAILURE); - } +// // Added error handling +// if(ptr == MAP_FAILED) +// { +// perror("mmap"); +// exit(EXIT_FAILURE); +// } - MallocCounter = (int)sz; +// MallocCounter = (int)sz; -} +// } // Quick malloc implementation with mmap void* MALLOCCHERI(size_t sz)