llvm-project/openmp/offload/src/cean_util.cpp

//===----------------------------------------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//


#include "cean_util.h"
#include "offload_common.h"

// 1. allocate element of CeanReadRanges type
// 2. initialized it for reading consequently contiguous ranges
//    described by "ap" argument
CeanReadRanges * init_read_ranges_arr_desc(const arr_desc *ap)
{
    CeanReadRanges * res;

    // find the max contiguous range
    int64_t rank = ap->rank - 1;
    int64_t length = ap->dim[rank].size;
    for (; rank >= 0; rank--) {
        if (ap->dim[rank].stride == 1) {
            length *= (ap->dim[rank].upper - ap->dim[rank].lower + 1);
            if (rank > 0 && length != ap->dim[rank - 1].size) {
                break;
            }
        }
        else {
            break;
        }
    }

    res =(CeanReadRanges *)malloc(sizeof(CeanReadRanges) +
                                  (ap->rank - rank) * sizeof(CeanReadDim));
    res->current_number = 0;
    res->range_size = length;
    res->last_noncont_ind = rank;

    // calculate number of contiguous ranges inside noncontiguous dimensions
    int count = 1;
    bool prev_is_cont = true;
    int64_t offset = 0;

    for (; rank >= 0; rank--) {
        res->Dim[rank].count = count;
        res->Dim[rank].size = ap->dim[rank].stride * ap->dim[rank].size;
        count *= (prev_is_cont && ap->dim[rank].stride == 1? 1 :
            (ap->dim[rank].upper - ap->dim[rank].lower +
            ap->dim[rank].stride) / ap->dim[rank].stride);
        prev_is_cont = false;
        offset +=(ap->dim[rank].lower - ap->dim[rank].lindex) *
                 ap->dim[rank].size;
    }
    res->range_max_number = count;
    res -> ptr = (void*)ap->base;
    res -> init_offset = offset;
    return res;
}

// check if ranges described by 1 argument could be transferred into ranges
// described by 2-nd one
bool cean_ranges_match(
    CeanReadRanges * read_rng1,
    CeanReadRanges * read_rng2
)
{
    return ( read_rng1 == NULL || read_rng2 == NULL ||
            (read_rng1->range_size % read_rng2->range_size == 0 ||
            read_rng2->range_size % read_rng1->range_size == 0));
}

// Set next offset and length and returns true for next range.
// Returns false if the ranges are over.
bool get_next_range(
    CeanReadRanges * read_rng,
    int64_t *offset
)
{
    if (++read_rng->current_number > read_rng->range_max_number) {
        read_rng->current_number = 0;
        return false;
    }
    int rank = 0;
    int num = read_rng->current_number - 1;
    int64_t cur_offset = 0;
    int num_loc;
    for (; rank <= read_rng->last_noncont_ind; rank++) {
        num_loc = num / read_rng->Dim[rank].count;
        cur_offset += num_loc * read_rng->Dim[rank].size;
        num = num % read_rng->Dim[rank].count;
    }
    *offset = cur_offset + read_rng->init_offset;
    return true;
}

bool is_arr_desc_contiguous(const arr_desc *ap)
{
    int64_t rank = ap->rank - 1;
    int64_t length = ap->dim[rank].size;
    for (; rank >= 0; rank--) {
        if (ap->dim[rank].stride > 1 &&
            ap->dim[rank].upper - ap->dim[rank].lower != 0) {
                return false;
        }
        else if (length != ap->dim[rank].size) {
            for (; rank >= 0; rank--) {
                if (ap->dim[rank].upper - ap->dim[rank].lower != 0) {
                    return false;
                }
            }
            return true;
        }
        length *= (ap->dim[rank].upper - ap->dim[rank].lower + 1);
    }
    return true;
}

int64_t cean_get_transf_size(CeanReadRanges * read_rng)
{
    return(read_rng->range_max_number * read_rng->range_size);
}

static uint64_t last_left, last_right;
typedef void (*fpp)(const char *spaces, uint64_t low, uint64_t high, int esize);

static void generate_one_range(
    const char *spaces,
    uint64_t lrange,
    uint64_t rrange,
    fpp fp,
    int esize
)
{
    OFFLOAD_TRACE(3,
        "%s    generate_one_range(lrange=%p, rrange=%p, esize=%d)\n",
        spaces, (void*)lrange, (void*)rrange, esize);
    if (last_left == -1) {
        // First range
        last_left = lrange;
    }
    else {
        if (lrange == last_right+1) {
            // Extend previous range, don't print
        }
        else {
            (*fp)(spaces, last_left, last_right, esize);
            last_left = lrange;
        }
    }
    last_right = rrange;
}

static void generate_mem_ranges_one_rank(
    const char *spaces,
    uint64_t base,
    uint64_t rank,
    const struct dim_desc *ddp,
    fpp fp,
    int esize
)
{
    uint64_t lindex = ddp->lindex;
    uint64_t lower = ddp->lower;
    uint64_t upper = ddp->upper;
    uint64_t stride = ddp->stride;
    uint64_t size = ddp->size;
    OFFLOAD_TRACE(3,
        "%s    "
        "generate_mem_ranges_one_rank(base=%p, rank=%lld, lindex=%lld, "
        "lower=%lld, upper=%lld, stride=%lld, size=%lld, esize=%d)\n",
        spaces, (void*)base, rank, lindex, lower, upper, stride, size, esize);
    if (rank == 1) {
        uint64_t lrange, rrange;
        if (stride == 1) {
            lrange = base + (lower-lindex)*size;
            rrange = lrange + (upper-lower+1)*size - 1;
            generate_one_range(spaces, lrange, rrange, fp, esize);
        }
        else {
            for (int i=lower-lindex; i<=upper-lindex; i+=stride) {
                lrange = base + i*size;
                rrange = lrange + size - 1;
                generate_one_range(spaces, lrange, rrange, fp, esize);
            }
        }
    }
    else {
        for (int i=lower-lindex; i<=upper-lindex; i+=stride) {
            generate_mem_ranges_one_rank(
                spaces, base+i*size, rank-1, ddp+1, fp, esize);

        }
    }
}

static void generate_mem_ranges(
    const char *spaces,
    const arr_desc *adp,
    bool deref,
    fpp fp
)
{
    uint64_t esize;

    OFFLOAD_TRACE(3,
        "%s    "
        "generate_mem_ranges(adp=%p, deref=%d, fp)\n",
        spaces, adp, deref);
    last_left = -1;
    last_right = -2;

    // Element size is derived from last dimension
    esize = adp->dim[adp->rank-1].size;

    generate_mem_ranges_one_rank(
        // For c_cean_var the base addr is the address of the data
        // For c_cean_var_ptr the base addr is dereferenced to get to the data
        spaces, deref ? *((uint64_t*)(adp->base)) : adp->base,
        adp->rank, &adp->dim[0], fp, esize);
    (*fp)(spaces, last_left, last_right, esize);
}

// returns offset and length of the data to be transferred
void __arr_data_offset_and_length(
    const arr_desc *adp,
    int64_t &offset,
    int64_t &length
)
{
    int64_t rank = adp->rank - 1;
    int64_t size = adp->dim[rank].size;
    int64_t r_off = 0; // offset from right boundary

    // find the rightmost dimension which takes just part of its
    // range. We define it if the size of left rank is not equal
    // the range's length between upper and lower boungaries
    while (rank > 0) {
        size *= (adp->dim[rank].upper - adp->dim[rank].lower + 1);
        if (size != adp->dim[rank - 1].size) {
            break;
        }
        rank--;
    }

    offset = (adp->dim[rank].lower - adp->dim[rank].lindex) *
             adp->dim[rank].size;

    // find gaps both from the left - offset and from the right - r_off
    for (rank--; rank >= 0; rank--) {
        offset += (adp->dim[rank].lower - adp->dim[rank].lindex) *
                  adp->dim[rank].size;
        r_off += adp->dim[rank].size -
                 (adp->dim[rank + 1].upper - adp->dim[rank + 1].lindex + 1) *
                 adp->dim[rank + 1].size;
    }
    length = (adp->dim[0].upper - adp->dim[0].lindex + 1) *
             adp->dim[0].size - offset - r_off;
}

#if OFFLOAD_DEBUG > 0

void print_range(
    const char *spaces,
    uint64_t low,
    uint64_t high,
    int esize
)
{
    char buffer[1024];
    char number[32];

    OFFLOAD_TRACE(3, "%s        print_range(low=%p, high=%p, esize=%d)\n",
        spaces, (void*)low, (void*)high, esize);

    if (console_enabled < 4) {
        return;
    }
    OFFLOAD_TRACE(4, "%s            values:\n", spaces);
    int count = 0;
    buffer[0] = '\0';
    while (low <= high)
    {
        switch (esize)
        {
        case 1:
            sprintf(number, "%d ", *((char *)low));
            low += 1;
            break;
        case 2:
            sprintf(number, "%d ", *((short *)low));
            low += 2;
            break;
        case 4:
            sprintf(number, "%d ", *((int *)low));
            low += 4;
            break;
        default:
            sprintf(number, "0x%016x ", *((uint64_t *)low));
            low += 8;
            break;
        }
        strcat(buffer, number);
        count++;
        if (count == 10) {
            OFFLOAD_TRACE(4, "%s            %s\n", spaces, buffer);
            count = 0;
            buffer[0] = '\0';
        }
    }
    if (count != 0) {
        OFFLOAD_TRACE(4, "%s            %s\n", spaces, buffer);
    }
}

void __arr_desc_dump(
    const char *spaces,
    const char *name,
    const arr_desc *adp,
    bool deref
)
{
    OFFLOAD_TRACE(2, "%s%s CEAN expression %p\n", spaces, name, adp);

    if (adp != 0) {
        OFFLOAD_TRACE(2, "%s    base=%llx, rank=%lld\n",
            spaces, adp->base, adp->rank);

        for (int i = 0; i < adp->rank; i++) {
            OFFLOAD_TRACE(2,
                          "%s    dimension %d: size=%lld, lindex=%lld, "
                          "lower=%lld, upper=%lld, stride=%lld\n",
                          spaces, i, adp->dim[i].size, adp->dim[i].lindex,
                          adp->dim[i].lower, adp->dim[i].upper,
                          adp->dim[i].stride);
        }
        // For c_cean_var the base addr is the address of the data
        // For c_cean_var_ptr the base addr is dereferenced to get to the data
        generate_mem_ranges(spaces, adp, deref, &print_range);
    }
}
#endif // OFFLOAD_DEBUG