ssr.h

Go to the documentation of this file.

// 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
 
#pragma once
 
inline void snrt_fpu_fence() {
    unsigned tmp;
    asm volatile(
        "fmv.x.w %0, fa0\n"
        "mv      %0, %0\n"
        : "+r"(tmp)::"memory");
}
 
typedef enum {
    SNRT_SSR_DM0 = 0,    
    SNRT_SSR_DM1 = 1,    
    SNRT_SSR_DM2 = 2,    
    SNRT_SSR_DM_ALL = 31 
} snrt_ssr_dm_t;
 
typedef enum {
    SNRT_SSR_1D = 0, 
    SNRT_SSR_2D = 1, 
    SNRT_SSR_3D = 2, 
    SNRT_SSR_4D = 3  
} snrt_ssr_dim_t;
 
typedef enum {
    SNRT_SSR_REG_STATUS = 0,      
    SNRT_SSR_REG_REPEAT = 1,      
    SNRT_SSR_REG_BOUNDS = 2,      
    SNRT_SSR_REG_STRIDES = 6,     
    SNRT_SSR_REG_IDX_CFG = 10,    
    SNRT_SSR_REG_IDX_BASE = 11,   
    SNRT_SSR_REG_RPTR_INDIR = 16, 
    SNRT_SSR_REG_RPTR = 24,       
    SNRT_SSR_REG_WPTR = 28        
} snrt_ssr_reg_t;
 
typedef enum {
    SNRT_SSR_IDXSIZE_U8 = 0,  
    SNRT_SSR_IDXSIZE_U16 = 1, 
    SNRT_SSR_IDXSIZE_U32 = 2, 
    SNRT_SSR_IDXSIZE_U64 = 3, 
} snrt_ssr_idxsize_t;
 
inline void snrt_ssr_enable() {
#ifdef SNRT_SUPPORTS_SSR
#ifdef __TOOLCHAIN_LLVM__
    __builtin_ssr_enable();
#else
    asm volatile("csrsi ssr, 1\n");
#endif
#endif
}
 
inline void snrt_ssr_disable() {
#ifdef SNRT_SUPPORTS_SSR
#ifdef __TOOLCHAIN_LLVM__
    __builtin_ssr_disable();
#else
    asm volatile("csrci ssr, 1\n");
#endif
#endif
}
 
inline void snrt_sc_enable(uint32_t mask) {
    asm volatile("csrs sc, %[mask]\n" : : [ mask ] "r"(mask) :);
}
 
inline void snrt_sc_disable(uint32_t mask) {
    asm volatile("csrc sc, %[mask]\n" : : [ mask ] "r"(mask) :);
}
 
static inline uint32_t read_ssr_cfg(const snrt_ssr_reg_t reg,
                                    const snrt_ssr_dm_t dm) {
#ifdef SNRT_SUPPORTS_SSR
    uint32_t value;
    asm volatile("scfgri %[value], %[dm] | %[reg]<<5\n"
                 : [ value ] "=r"(value)
                 : [ dm ] "i"(dm), [ reg ] "i"(reg));
    return value;
#else
    return 0;
#endif
}
 
static inline void write_ssr_cfg(const snrt_ssr_reg_t reg,
                                 const snrt_ssr_dm_t dm, uint32_t value) {
#ifdef SNRT_SUPPORTS_SSR
    asm volatile("scfgwi %[value], %[dm] | %[reg]<<5\n" ::[value] "r"(value),
                 [ dm ] "i"(dm), [ reg ] "i"(reg));
#endif
}
 
static inline void snrt_ssr_loop_1d(const snrt_ssr_dm_t dm, size_t b0,
                                    size_t s0) {
    --b0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 0), dm, b0);
    size_t a = 0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 0), dm, s0 - a);
    a += s0 * b0;
}
 
static inline void snrt_ssr_loop_2d(const snrt_ssr_dm_t dm, size_t b0,
                                    size_t b1, size_t s0, size_t s1) {
    --b0;
    --b1;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 0), dm, b0);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 1), dm, b1);
    size_t a = 0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 0), dm, s0 - a);
    a += s0 * b0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 1), dm, s1 - a);
    a += s1 * b1;
}
 
static inline void snrt_ssr_loop_3d(const snrt_ssr_dm_t dm, size_t b0,
                                    size_t b1, size_t b2, size_t s0, size_t s1,
                                    size_t s2) {
    --b0;
    --b1;
    --b2;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 0), dm, b0);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 1), dm, b1);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 2), dm, b2);
    size_t a = 0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 0), dm, s0 - a);
    a += s0 * b0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 1), dm, s1 - a);
    a += s1 * b1;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 2), dm, s2 - a);
    a += s2 * b2;
}
 
static inline void snrt_ssr_loop_4d(const snrt_ssr_dm_t dm, size_t b0,
                                    size_t b1, size_t b2, size_t b3, size_t s0,
                                    size_t s1, size_t s2, size_t s3) {
    --b0;
    --b1;
    --b2;
    --b3;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 0), dm, b0);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 1), dm, b1);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 2), dm, b2);
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_BOUNDS + 3), dm, b3);
    size_t a = 0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 0), dm, s0 - a);
    a += s0 * b0;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 1), dm, s1 - a);
    a += s1 * b1;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 2), dm, s2 - a);
    a += s2 * b2;
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_STRIDES + 3), dm, s3 - a);
    a += s3 * b3;
}
 
static inline void snrt_ssr_repeat(const snrt_ssr_dm_t dm, size_t count) {
    write_ssr_cfg(SNRT_SSR_REG_REPEAT, dm, count - 1);
}
 
static inline void snrt_ssr_read(const snrt_ssr_dm_t dm,
                                 const snrt_ssr_dim_t dim, volatile void *ptr) {
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_RPTR + dim), dm,
                  (uintptr_t)ptr);
}
 
static inline void snrt_ssr_write(const snrt_ssr_dm_t dm,
                                  const snrt_ssr_dim_t dim,
                                  volatile void *ptr) {
    write_ssr_cfg((snrt_ssr_reg_t)(SNRT_SSR_REG_WPTR + dim), dm,
                  (uintptr_t)ptr);
}
 
static inline void snrt_issr_set_idx_cfg(const snrt_ssr_dm_t dm,
                                         snrt_ssr_idxsize_t idxsize) {
    write_ssr_cfg(SNRT_SSR_REG_IDX_CFG, dm, (idxsize & 0xFF));
}
 
static inline void snrt_issr_set_bound(const snrt_ssr_dm_t dm, size_t bound) {
    write_ssr_cfg(SNRT_SSR_REG_BOUNDS, dm, --bound);
}
 
static inline void snrt_issr_set_ptrs(const snrt_ssr_dm_t dm,
                                      volatile void *base,
                                      volatile void *idcs) {
    write_ssr_cfg(SNRT_SSR_REG_IDX_BASE, dm, (uintptr_t)base);
    write_ssr_cfg(SNRT_SSR_REG_RPTR_INDIR, dm, (uintptr_t)idcs);
}
 
static inline void snrt_issr_read(const snrt_ssr_dm_t dm, volatile void *base,
                                  volatile void *idcs, size_t bound,
                                  snrt_ssr_idxsize_t idxsize) {
    snrt_issr_set_idx_cfg(dm, idxsize);
    snrt_issr_set_bound(dm, bound);
    snrt_issr_set_ptrs(dm, base, idcs);
}