alloc_v2.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
 
//================================================================================
// L1 allocation
//================================================================================
 
extern __thread snrt_allocator_t l1_allocator_v2;
 
inline snrt_allocator_t *snrt_l1_allocator_v2() { return &l1_allocator_v2; }
 
inline void *snrt_l1_next_v2() { return (void *)snrt_l1_allocator_v2()->next; }
 
inline void *snrt_l1_next_aligned_hyperbank() {
    return snrt_align_up_hyperbank(snrt_l1_next_v2());
}
 
inline void snrt_l1_update_next_v2(void *next) {
    snrt_l1_allocator_v2()->next = (uint32_t)next;
}
 
static inline void snrt_l1_alloc_check_bounds() {
    if (snrt_l1_allocator_v2()->next > snrt_l1_allocator_v2()->end)
        asm volatile("ecall \n");
}
 
inline void *snrt_l1_alloc_cluster_local(size_t size,
                                         const size_t alignment = 1) {
    snrt_l1_allocator_v2()->next =
        snrt_align_up(snrt_l1_allocator_v2()->next, alignment);
    void *retval = snrt_l1_next_v2();
    snrt_l1_allocator_v2()->next += size;
    snrt_l1_alloc_check_bounds();
    return retval;
}
 
template <typename T>
inline T *snrt_l1_alloc_cluster_local(size_t count = 1,
                                      const size_t alignment = alignof(T)) {
    snrt_l1_allocator_v2()->next =
        snrt_align_up(snrt_l1_allocator_v2()->next, alignment);
    T *retval = (T *)snrt_l1_next_v2();
    snrt_l1_allocator_v2()->next += count * sizeof(T);
    snrt_l1_alloc_check_bounds();
    return retval;
}
 
inline void *snrt_l1_alloc_compute_core_local(size_t size,
                                              const size_t alignment = 1) {
    snrt_l1_allocator_v2()->next =
        snrt_align_up(snrt_l1_allocator_v2()->next, alignment);
    void *retval =
        ((uint8_t *)snrt_l1_next_v2()) + size * snrt_cluster_core_idx();
    snrt_l1_allocator_v2()->next += size * snrt_cluster_compute_core_num();
    snrt_l1_alloc_check_bounds();
    return retval;
}
 
inline void snrt_l1_init() {
    // Calculate end address of the heap. The top of the TCDM address space is
    // reserved for the cluster-local storage (CLS) and the stack of every
    // core. We further provision a safety margin of 128B. The rest of the
    // TCDM is reserved for the heap.
    uint32_t heap_end_addr = snrt_cls_base_addr();
    heap_end_addr -= (1 << SNRT_LOG2_STACK_SIZE) * snrt_cluster_core_num();
    heap_end_addr -= 128;
    // Initialize L1 allocator
    uintptr_t l1_start_addr = (uintptr_t)(snrt_cluster()->tcdm.mem);
    snrt_l1_allocator_v2()->base = snrt_align_up(l1_start_addr, MIN_CHUNK_SIZE);
    snrt_l1_allocator_v2()->end = heap_end_addr;
    snrt_l1_allocator_v2()->next = snrt_l1_allocator_v2()->base;
}
 
//================================================================================
// L3 allocation
//================================================================================
 
extern __thread snrt_allocator_t l3_allocator_v2;
 
inline snrt_allocator_t *snrt_l3_allocator_v2() { return &l3_allocator_v2; }
 
inline void *snrt_l3_next_v2() { return (void *)snrt_l3_allocator_v2()->next; }
 
static inline void snrt_l3_alloc_check_bounds() {
    if (snrt_l3_allocator_v2()->next >= snrt_l3_allocator_v2()->end)
        asm volatile("ecall \n");
}
 
inline void *snrt_l3_alloc_v2(size_t size, const size_t alignment = 1) {
    snrt_l3_allocator_v2()->next =
        snrt_align_up(snrt_l3_allocator_v2()->next, alignment);
    void *retval = snrt_l3_next_v2();
    snrt_l3_allocator_v2()->next += size;
    snrt_l3_alloc_check_bounds();
    return retval;
}
 
inline void snrt_l3_init() {
    extern uint32_t _edram;
    snrt_l3_allocator_v2()->base =
        snrt_align_up((uint32_t)&_edram, MIN_CHUNK_SIZE);
    snrt_l3_allocator_v2()->end = SNRT_L3_END_ADDR;
    snrt_l3_allocator_v2()->next = snrt_l3_allocator_v2()->base;
}
 
//================================================================================
// Pointer translation functions
//================================================================================
 
inline void *snrt_compute_core_local_ptr(void *ptr, uint32_t core_idx,
                                         size_t size) {
    size_t offset = (core_idx - snrt_cluster_core_idx()) * size;
    return (void *)((uintptr_t)ptr + offset);
}
 
inline void *snrt_remote_l1_ptr(void *ptr, uint32_t src_cluster_idx,
                                uint32_t dst_cluster_idx) {
    return (void *)((uintptr_t)ptr +
                    (dst_cluster_idx - src_cluster_idx) * SNRT_CLUSTER_OFFSET);
}