| //===----------------------------------------------------------------------===// |
| // |
| // 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 |