Add pulp-offload-intf.c to stimulate and test CVA6-PULP cluster interference

scripts/elf2header.py

@@ -17,6 +17,7 @@
 #
 
 from elftools.elf.elffile import ELFFile
+from elftools.elf.sections import SymbolTableSection
 import os
 import os.path
 import struct
@@ -62,6 +63,7 @@ def __init__(self, verbose=False):
     self.mem = {}
     self.verbose = verbose
     self.areas = []
+    self.start_addr = 0
 
     self.dump('Created stimuli generator')
 
@@ -142,6 +144,8 @@ def __gen_stim_header(self, filename, width):
 
     with open(filename, 'w') as file:
       file.write(c_header)
+      if(self.start_addr!=0):
+        file.write('#define ELF_BOOT_ADDR %s \n' %(hex(self.start_addr)))
       file.write('int load_binary() {\n' )
       file.write(c_function)
       for key in sorted(self.mem.keys()):
@@ -150,6 +154,19 @@ def __gen_stim_header(self, filename, width):
       file.write('return 0; \n }\n')
 
 
+  def __get_start_addr(self,filename,width):
+
+    for binary in self.binaries:
+
+      with open(binary, 'rb') as file:
+        elffile = ELFFile(file)
+        for section in elffile.iter_sections():
+          if isinstance(section, SymbolTableSection):
+            for symbol in section.iter_symbols():
+              if symbol.name == "_start":
+                self.start_addr = symbol.entry['st_value']
+                break
+
   def __parse_binaries(self, width):
 
     self.mem = {}
@@ -196,6 +213,8 @@ def gen_stim_header_32(self, stim_file):
 
     self.__parse_binaries(4)
 
+    self.__get_start_addr(stim_file, 4)
+
     self.__gen_stim_header(stim_file, 4)
 
   def gen_stim_slm_64(self, stim_file):

sw/sw.mk

@@ -61,9 +61,11 @@ CAR_ELFLOAD_BLOCKING_SAFED_SRC_C := $(CAR_SW_DIR)/tests/bare-metal/hostd/safed_o
 CAR_ELFLOAD_BLOCKING_SAFED_PATH := $(basename $(CAR_ELFLOAD_BLOCKING_SAFED_SRC_C))
 CAR_ELFLOAD_PULPD_SRC_C := $(CAR_SW_DIR)/tests/bare-metal/hostd/pulp-offload.c
 CAR_ELFLOAD_PULPD_PATH := $(basename $(CAR_ELFLOAD_PULPD_SRC_C))
+CAR_ELFLOAD_PULPD_INTF_SRC_C := $(CAR_SW_DIR)/tests/bare-metal/hostd/pulp-offload-intf.c
+CAR_ELFLOAD_PULPD_INTF_PATH := $(basename $(CAR_ELFLOAD_PULPD_INTF_SRC_C))
 
 CAR_SW_TEST_SRCS_S	= $(wildcard $(CAR_SW_DIR)/tests/bare-metal/hostd/*.S)
-CAR_SW_TEST_SRCS_C	= $(filter-out $(CAR_ELFLOAD_BLOCKING_SAFED_SRC_C) $(CAR_ELFLOAD_PULPD_SRC_C), $(wildcard $(CAR_SW_DIR)/tests/bare-metal/hostd/*.c))
+CAR_SW_TEST_SRCS_C	= $(filter-out $(CAR_ELFLOAD_BLOCKING_SAFED_SRC_C) $(CAR_ELFLOAD_PULPD_SRC_C) $(CAR_ELFLOAD_PULPD_INTF_SRC_C), $(wildcard $(CAR_SW_DIR)/tests/bare-metal/hostd/*.c))
 
 CAR_SW_TEST_DRAM_DUMP	= $(CAR_SW_TEST_SRCS_S:.S=.car.dram.dump) $(CAR_SW_TEST_SRCS_C:.c=.car.dram.dump)
 CAR_SW_TEST_DRAM_SLM	= $(CAR_SW_TEST_SRCS_S:.S=.car.dram.slm)  $(CAR_SW_TEST_SRCS_C:.c=.car.dram.slm)
@@ -104,6 +106,7 @@ include $(CAR_SW_DIR)/tests/bare-metal/pulpd/sw.mk
 
 car-pulpd-sw-offload-tests:
 	$(call offload_tests_template,$(PULPD_HEADER_TARGETS),pulpd,$(CAR_ELFLOAD_PULPD_SRC_C),$(CAR_ELFLOAD_PULPD_PATH))
+	$(call offload_tests_template,$(PULPD_HEADER_TARGETS),pulpd,$(CAR_ELFLOAD_PULPD_INTF_SRC_C),$(CAR_ELFLOAD_PULPD_INTF_PATH))
 
 # Litmus tests
 LITMUS_REPO := https://github.com/pulp-platform/CHERI-Litmus.git

sw/tests/bare-metal/hostd/pulp-offload-intf.c

@@ -0,0 +1,120 @@
+// Copyright 2023 ETH Zurich and University of Bologna.
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Luca Valente <[email protected]>
+//
+// Bare-metal offload test for the PULP cluster with interference
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "car_memory_map.h"
+#include "car_util.h"
+#include "dif/clint.h"
+#include "dif/uart.h"
+#include "params.h"
+#include "regs/cheshire.h"
+#include "csr.h"
+#include "util.h"
+#include "payload.h"
+#include "printf.h"
+
+#define LCL
+
+long int buffer[128];
+
+void read_from_cache(int l1_way_size, int stride) {
+    asm volatile("": : :"memory");
+    for(volatile int j = 0; j < l1_way_size; j++)
+    {
+      * ( ( volatile long int * ) &buffer[j] );
+    }
+    asm volatile("": : :"memory");
+    for(volatile int j = 0; j < l1_way_size; j++)
+    {
+      * ( ( volatile long int * ) &buffer[j*stride]);
+    }
+    asm volatile("": : :"memory");
+}
+
+long unsigned sweep(int stride)
+{
+
+  int l1_way_size = 4 * 1024 / 8;
+  int working_set = l1_way_size * stride * 8;
+
+  volatile long unsigned cycle_start;
+
+  for(int i = 0; i < 10; i++)
+  {
+    if(i==1)
+    {
+      cycle_start = get_mcycle();
+    }
+    read_from_cache(l1_way_size, stride);
+  }
+
+  volatile long unsigned cycles = get_mcycle() - cycle_start;
+
+  #ifdef VERBOSE
+  printf("%3dKB        , %6d     \r\n",
+           working_set / 1024, (int)cycles);
+  #endif
+
+  return cycles;
+}
+
+int main(void)
+{
+  // Set the LLC as LLC
+  axi_llc_reg32_all_cache(&__base_llc);
+  writew(0x18,CAR_HYPERBUS_CFG_BASE_ADDR+0x18);
+  volatile uint32_t pulp_ret_val = 0;
+  // Init the HW
+  // PULP Island
+  #ifdef LCL
+  car_enable_domain(CAR_PULP_RST);
+  char str[] = "Cluster boot.\r\n";
+  uint32_t rtc_freq = *reg32(&__base_regs, CHESHIRE_RTC_FREQ_REG_OFFSET);
+  uint64_t reset_freq = clint_get_core_freq(rtc_freq, 2500);
+
+  load_binary();
+
+  volatile uint32_t pulp_boot_default = ELF_BOOT_ADDR;
+
+  pulp_cluster_set_bootaddress(pulp_boot_default);
+
+  uart_init(&__base_uart, reset_freq, 115200);
+  uart_write_str(&__base_uart, str, sizeof(str));
+  uart_write_flush(&__base_uart);
+
+  pulp_cluster_start();
+  #endif
+
+  #ifdef VERBOSE
+  printf("Buffer: %x\n", buffer);
+  #endif
+
+  volatile long unsigned cycles[5];
+  int j=0;
+  for( int i = 4; i<128; i=i*2){
+    cycles[j] = sweep(i);
+    j++;
+  }
+
+  #ifdef LCL
+  pulp_cluster_wait_eoc();
+
+  pulp_ret_val = pulp_cluster_get_return();
+  #endif
+
+
+  for(int i=0;i<5;i++)
+    printf("%d\r\n",cycles[i]);
+
+  printf("Done\n");
+
+  return pulp_ret_val;
+
+}

sw/tests/bare-metal/hostd/pulp-offload.c

@@ -30,7 +30,7 @@ int main(void)
 
   load_binary();
 
-  volatile uint32_t pulp_boot_default = 0x78008080;
+  volatile uint32_t pulp_boot_default = ELF_BOOT_ADDR;
   volatile uint32_t pulp_ret_val = 0;
 
   pulp_cluster_set_bootaddress(pulp_boot_default);