Add wasm tacle-bench targets

targets/wasm-tacle/kernel/binarysearch/CMakeLists.txt

@@ -0,0 +1,25 @@
+# ~~~
+# SPDX-License-Identifier: MIT
+# SPDX-FileCopyrightText: 2026, Friedrich-Alexander-Universität Erlangen-Nürnberg (FAU)
+# ~~~
+
+cmake_minimum_required(VERSION 3.20)
+
+project(binarysearch)
+
+set(TACLEBENCH_ROOT_PATH "${CMAKE_CURRENT_LIST_DIR}/../../..")
+set(REPOSITORY_ROOT_PATH "${CMAKE_CURRENT_LIST_DIR}/../../../..")
+
+set(APP_TARGET_NAME "${CMAKE_PROJECT_NAME}")
+
+if(DEFINED TACLEBENCH_VARIANT AND "${TACLEBENCH_VARIANT}" STREQUAL "inline")
+    set(APP_SOURCE_FILE_PATH 
+        "generated/modified_sources/inline/binarysearch.c")
+else()
+    set(APP_SOURCE_FILE_PATH 
+        "generated/modified_sources/default/binarysearch.c")
+endif()
+
+include(${REPOSITORY_ROOT_PATH}/cmake/taclebench_wasm.cmake)
+
+

targets/wasm-tacle/kernel/binarysearch/ChangeLog.txt

@@ -0,0 +1,42 @@
+File: binarysearch.c
+Original provenience: Mälardalen benchmark suite,
+                      http://www.mrtc.mdh.se/projects/wcet/wcet_bench/bs
+
+2015-10-10:
+- Removed original header comment, replaced by TACLeBench header.
+- Added prefix "binarysearch_" to all global symbols.
+- Added explicit forward declarations of functions, removed obsolete forward
+  declaration of function binary_search.
+- Replaced initialization of global array "binarysearch_data" by
+  TACLeBench-compliant initialization code.
+- Added new global variable "binarysearch_result" to store the found return
+  value.
+- Added new function binarysearch_return producing the searched data element as
+  return value.
+- Removed global variable "binarysearch_cnt1" that was used for profiling.
+- Added new function binarysearch_main according to TACLeBench guidelines.
+  binarysearch_main is annotated as entry-point for timing analysis.
+- Corrected flow fact in function "binarysearch_binary_search" to cover the
+  interval [1, 4] instead of [4, 4].
+- Applied code formatting according to the following rules
+  - Lines shall not be wider than 80 characters; whenever possible, appropriate
+    line breaks shall be inserted to keep lines below 80 characters
+  - Indentation is done using whitespaces only, no tabs. Code is indented by
+    two whitespaces
+  - Two empty lines are put between any two functions
+  - In non-empty lists or index expressions, opening '(' and '[' are followed by
+    one whitespace, closing ')' and ']' are preceded by one whitespace
+  - In comma- or colon-separated argument lists, one whitespace is put after
+    each comma/colon
+  - Names of functions and global variables all start with a benchmark-specific
+    prefix (here: binarysearch_) followed by lowercase letter (e.g.,
+    binarysearch_square)
+  - For pointer types, one whitespace is put before the '*'
+  - Operators within expressions shall be preceded and followed by one
+    whitespace
+  - Code of then- and else-parts of if-then-else statements shall be put in
+    separate lines, not in the same lines as the if-condition or the keyword
+    "else"
+  - Opening braces '{' denoting the beginning of code for some if-else or loop
+    body shall be put at the end of the same line where the keywords "if",
+    "else", "for", "while" etc. occur

targets/wasm-tacle/kernel/binarysearch/binarysearch.c

@@ -0,0 +1,156 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 2.0
+
+  Name: binarysearch
+
+  Author: Sung-Soo Lim <sslim@archi.snu.ac.kr>
+
+  Function: binarysearch performs binary search in an array of 15 integer
+    elements.
+    This program is completely structured (no unconditional jumps, no exits
+    from loop bodies), and does not contain switch statements, no do-while
+    loops.
+
+  Source: MRTC
+          http://www.mrtc.mdh.se/projects/wcet/wcet_bench/bs/bs.c
+
+  Original name: bs
+
+  Changes: No major functional changes.
+
+  License: May be used, modified, and re-distributed freely, but
+           the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+  This program is derived from the SNU-RT Benchmark Suite for Worst
+  Case Timing Analysis by Sung-Soo Lim
+*/
+
+
+/*
+  Forward declaration of functions
+*/
+
+void binarysearch_initSeed( void );
+long binarysearch_randomInteger( void );
+void binarysearch_init( void );
+int binarysearch_return( void );
+int binarysearch_binary_search( int );
+void binarysearch_main( void );
+int main( void );
+
+
+/*
+  Declaration of global variables
+*/
+
+volatile int binarysearch_seed;
+
+struct binarysearch_DATA {
+  int key;
+  int value;
+};
+
+struct binarysearch_DATA binarysearch_data[ 15 ];
+
+int binarysearch_result;
+
+
+/*
+  Initialization- and return-value-related functions
+*/
+
+/*
+  binarysearch_initSeed initializes the seed used in the "random" number
+  generator.
+*/
+void binarysearch_initSeed( void )
+{
+  binarysearch_seed = 0;
+}
+
+
+/*
+  binarysearch_RandomInteger generates "random" integers between 0 and 8094.
+*/
+long binarysearch_randomInteger( void )
+{
+  binarysearch_seed = ( ( binarysearch_seed * 133 ) + 81 ) % 8095;
+  return ( binarysearch_seed );
+}
+
+
+void binarysearch_init( void )
+{
+  int i;
+
+  binarysearch_initSeed();
+
+  _Pragma( "loopbound min 15 max 15" )
+  for ( i = 0; i < 15; ++i ) {
+    binarysearch_data[ i ].key = binarysearch_randomInteger();
+    binarysearch_data[ i ].value = binarysearch_randomInteger();
+  }
+}
+
+
+int binarysearch_return( void )
+{
+  return ( binarysearch_result );
+}
+
+
+/*
+  Algorithm core functions
+*/
+
+int binarysearch_binary_search( int x )
+{
+  int fvalue, mid, up, low;
+
+  low = 0;
+  up = 14;
+  fvalue = -1;
+
+  _Pragma( "loopbound min 1 max 4" )
+  while ( low <= up ) {
+    mid = ( low + up ) >> 1;
+
+    if ( binarysearch_data[ mid ].key == x ) {
+      /* Item found */
+      up = low - 1;
+      fvalue = binarysearch_data[ mid ].value;
+    } else
+
+      if ( binarysearch_data[ mid ].key > x )
+        /* Item not found */
+        up = mid - 1;
+      else
+        low = mid + 1;
+  }
+
+  return ( fvalue );
+}
+
+
+/*
+  Main functions
+*/
+
+void _Pragma( "entrypoint" ) binarysearch_main( void )
+{
+  binarysearch_result = binarysearch_binary_search( 8 );
+}
+
+
+int main( void )
+{
+  binarysearch_init();
+  binarysearch_main();
+
+  return ( binarysearch_return() - ( -1 ) != 0 );
+}

targets/wasm-tacle/kernel/binarysearch/generated/default/binarysearch.wat

@@ -0,0 +1,132 @@
+(module $binarysearch.wasm
+  (type (;0;) (func (param i32 i32)))
+  (type (;1;) (func))
+  (type (;2;) (func (result i32)))
+  (import "__pragma" "loopbound" (func $__pragma_loopbound (type 0)))
+  (func $__wasm_apply_data_relocs (type 1))
+  (func $binarysearch_main (type 1)
+    (local i32 i32 i32 i32 i32)
+    i32.const 1
+    i32.const 4
+    call $__pragma_loopbound
+    i32.const 14
+    local.set 0
+    i32.const 0
+    local.set 1
+    block  ;; label = @1
+      loop  ;; label = @2
+        block  ;; label = @3
+          local.get 0
+          local.get 1
+          i32.add
+          i32.const 1
+          i32.shr_s
+          local.tee 2
+          i32.const 3
+          i32.shl
+          i32.const 1040
+          i32.add
+          local.tee 3
+          i32.load
+          local.tee 4
+          i32.const 8
+          i32.ne
+          br_if 0 (;@3;)
+          local.get 3
+          i32.load offset=4
+          local.set 3
+          br 2 (;@1;)
+        end
+        i32.const -1
+        local.set 3
+        local.get 1
+        local.get 2
+        i32.const 1
+        i32.add
+        local.get 4
+        i32.const 8
+        i32.gt_s
+        local.tee 4
+        select
+        local.tee 1
+        local.get 2
+        i32.const -1
+        i32.add
+        local.get 0
+        local.get 4
+        select
+        local.tee 0
+        i32.le_s
+        br_if 0 (;@2;)
+      end
+    end
+    i32.const 0
+    local.get 3
+    i32.store offset=1160)
+  (func $__original_main (type 2) (result i32)
+    (local i32 i32)
+    i32.const 0
+    i32.const 0
+    i32.store offset=1024
+    i32.const 15
+    i32.const 15
+    call $__pragma_loopbound
+    i32.const -120
+    local.set 0
+    loop  ;; label = @1
+      i32.const 0
+      i32.const 0
+      i32.load offset=1024
+      i32.const 133
+      i32.mul
+      i32.const 81
+      i32.add
+      i32.const 8095
+      i32.rem_s
+      i32.store offset=1024
+      i32.const 0
+      i32.load offset=1024
+      local.set 1
+      i32.const 0
+      i32.const 0
+      i32.load offset=1024
+      i32.const 133
+      i32.mul
+      i32.const 81
+      i32.add
+      i32.const 8095
+      i32.rem_s
+      i32.store offset=1024
+      local.get 0
+      i32.const 1160
+      i32.add
+      local.get 1
+      i32.store
+      local.get 0
+      i32.const 1164
+      i32.add
+      i32.const 0
+      i32.load offset=1024
+      i32.store
+      local.get 0
+      i32.const 8
+      i32.add
+      local.tee 0
+      br_if 0 (;@1;)
+    end
+    call $binarysearch_main
+    i32.const 0
+    i32.load offset=1160
+    i32.const -1
+    i32.ne)
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) 1)
+  (global $__stack_pointer (mut i32) (i32.const 5264))
+  (global (;1;) i32 (i32.const 1164))
+  (global (;2;) i32 (i32.const 5264))
+  (export "memory" (memory 0))
+  (export "__wasm_apply_data_relocs" (func $__wasm_apply_data_relocs))
+  (export "entrypoint" (func $binarysearch_main))
+  (export "main" (func $__original_main))
+  (export "__data_end" (global 1))
+  (export "__heap_base" (global 2)))

targets/wasm-tacle/kernel/binarysearch/generated/modified_sources/default/binarysearch.c

@@ -0,0 +1,153 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 2.0
+
+  Name: binarysearch
+
+  Author: Sung-Soo Lim <sslim@archi.snu.ac.kr>
+
+  Function: binarysearch performs binary search in an array of 15 integer
+    elements.
+    This program is completely structured (no unconditional jumps, no exits
+    from loop bodies), and does not contain switch statements, no do-while
+    loops.
+
+  Source: MRTC
+          http://www.mrtc.mdh.se/projects/wcet/wcet_bench/bs/bs.c
+
+  Original name: bs
+
+  Changes: No major functional changes.
+
+  License: May be used, modified, and re-distributed freely, but
+           the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+  This program is derived from the SNU-RT Benchmark Suite for Worst
+  Case Timing Analysis by Sung-Soo Lim
+*/
+
+/*
+  Forward declaration of functions
+*/
+
+// Wasm loop bounds
+
+__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
+__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
+
+void binarysearch_initSeed(void);
+long binarysearch_randomInteger(void);
+void binarysearch_init(void);
+int binarysearch_return(void);
+int binarysearch_binary_search(int);
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+binarysearch_main(void);
+__attribute__((noinline)) __attribute__((export_name("main"))) int main(void);
+
+/*
+  Declaration of global variables
+*/
+
+volatile int binarysearch_seed;
+
+struct binarysearch_DATA {
+    int key;
+    int value;
+};
+
+struct binarysearch_DATA binarysearch_data[15];
+
+int binarysearch_result;
+
+/*
+  Initialization- and return-value-related functions
+*/
+
+/*
+  binarysearch_initSeed initializes the seed used in the "random" number
+  generator.
+*/
+void
+binarysearch_initSeed(void) {
+    binarysearch_seed = 0;
+}
+
+/*
+  binarysearch_RandomInteger generates "random" integers between 0 and 8094.
+*/
+long
+binarysearch_randomInteger(void) {
+    binarysearch_seed = ((binarysearch_seed * 133) + 81) % 8095;
+    return (binarysearch_seed);
+}
+
+void
+binarysearch_init(void) {
+    int i;
+
+    binarysearch_initSeed();
+
+    __pragma_loopbound(15, 15);
+    for (i = 0; i < 15; ++i) {
+        binarysearch_data[i].key = binarysearch_randomInteger();
+        binarysearch_data[i].value = binarysearch_randomInteger();
+    }
+}
+
+int
+binarysearch_return(void) {
+    return (binarysearch_result);
+}
+
+/*
+  Algorithm core functions
+*/
+
+int
+binarysearch_binary_search(int x) {
+    int fvalue, mid, up, low;
+
+    low = 0;
+    up = 14;
+    fvalue = -1;
+
+    __pragma_loopbound(1, 4);
+    while (low <= up) {
+        mid = (low + up) >> 1;
+
+        if (binarysearch_data[mid].key == x) {
+            /* Item found */
+            up = low - 1;
+            fvalue = binarysearch_data[mid].value;
+        } else
+
+            if (binarysearch_data[mid].key > x)
+            /* Item not found */
+            up = mid - 1;
+        else
+            low = mid + 1;
+    }
+
+    return (fvalue);
+}
+
+/*
+  Main functions
+*/
+
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+binarysearch_main(void) {
+    binarysearch_result = binarysearch_binary_search(8);
+}
+
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void) {
+    binarysearch_init();
+    binarysearch_main();
+
+    return (binarysearch_return() - (-1) != 0);
+}

targets/wasm-tacle/kernel/binarysearch/generated/modified_sources/inline/binarysearch.c

@@ -0,0 +1,163 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 2.0
+
+  Name: binarysearch
+
+  Author: Sung-Soo Lim <sslim@archi.snu.ac.kr>
+
+  Function: binarysearch performs binary search in an array of 15 integer
+    elements.
+    This program is completely structured (no unconditional jumps, no exits
+    from loop bodies), and does not contain switch statements, no do-while
+    loops.
+
+  Source: MRTC
+          http://www.mrtc.mdh.se/projects/wcet/wcet_bench/bs/bs.c
+
+  Original name: bs
+
+  Changes: No major functional changes.
+
+  License: May be used, modified, and re-distributed freely, but
+           the SNU-RT Benchmark Suite must be acknowledged
+
+*/
+
+/*
+  This program is derived from the SNU-RT Benchmark Suite for Worst
+  Case Timing Analysis by Sung-Soo Lim
+*/
+
+/*
+  Forward declaration of functions
+*/
+
+// Wasm loop bounds
+
+
+
+
+__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
+__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
+
+__attribute__((always_inline)) static inline void binarysearch_initSeed(void);
+__attribute__((always_inline)) static inline long
+binarysearch_randomInteger(void);
+__attribute__((always_inline)) static inline void binarysearch_init(void);
+__attribute__((always_inline)) static inline int binarysearch_return(void);
+__attribute__((always_inline)) static inline int
+binarysearch_binary_search(int);
+__attribute__((noinline)) __attribute__((export_name("entrypoint")))
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+binarysearch_main(void);
+__attribute__((noinline)) __attribute__((export_name("main")))
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void);
+
+/*
+  Declaration of global variables
+*/
+
+volatile int binarysearch_seed;
+
+struct binarysearch_DATA {
+    int key;
+    int value;
+};
+
+struct binarysearch_DATA binarysearch_data[15];
+
+int binarysearch_result;
+
+/*
+  Initialization- and return-value-related functions
+*/
+
+/*
+  binarysearch_initSeed initializes the seed used in the "random" number
+  generator.
+*/
+__attribute__((always_inline)) static inline void
+binarysearch_initSeed(void) {
+    binarysearch_seed = 0;
+}
+
+/*
+  binarysearch_RandomInteger generates "random" integers between 0 and 8094.
+*/
+__attribute__((always_inline)) static inline long
+binarysearch_randomInteger(void) {
+    binarysearch_seed = ((binarysearch_seed * 133) + 81) % 8095;
+    return (binarysearch_seed);
+}
+
+__attribute__((always_inline)) static inline void
+binarysearch_init(void) {
+    int i;
+
+    binarysearch_initSeed();
+
+    __pragma_loopbound(15, 15);
+    for (i = 0; i < 15; ++i) {
+        binarysearch_data[i].key = binarysearch_randomInteger();
+        binarysearch_data[i].value = binarysearch_randomInteger();
+    }
+}
+
+__attribute__((always_inline)) static inline int
+binarysearch_return(void) {
+    return (binarysearch_result);
+}
+
+/*
+  Algorithm core functions
+*/
+
+__attribute__((always_inline)) static inline int
+binarysearch_binary_search(int x) {
+    int fvalue, mid, up, low;
+
+    low = 0;
+    up = 14;
+    fvalue = -1;
+
+    __pragma_loopbound(1, 4);
+    while (low <= up) {
+        mid = (low + up) >> 1;
+
+        if (binarysearch_data[mid].key == x) {
+            /* Item found */
+            up = low - 1;
+            fvalue = binarysearch_data[mid].value;
+        } else
+
+            if (binarysearch_data[mid].key > x)
+            /* Item not found */
+            up = mid - 1;
+        else
+            low = mid + 1;
+    }
+
+    return (fvalue);
+}
+
+/*
+  Main functions
+*/
+
+__attribute__((noinline)) __attribute__((export_name("entrypoint")))
+__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
+binarysearch_main(void) {
+    binarysearch_result = binarysearch_binary_search(8);
+}
+
+__attribute__((noinline)) __attribute__((export_name("main")))
+__attribute__((noinline)) __attribute__((export_name("main"))) int
+main(void) {
+    binarysearch_init();
+    binarysearch_main();
+
+    return (binarysearch_return() - (-1) != 0);
+}