breagen / machsuite Goto Github PK

Backprop seems fail the test with default input and check data. I did a fresh clone and call make run for backprop. Is there anything that I missed?

Thanks

I have been using Machsuite to benchmark a tool that we're developing. However, when I try to do a 'make hls', I get linking errors (underfined references).
So, I copied the support.c and support.h files to all benchmarks local directories and added local_support.c and support.c to the hls.tcl file.

Now, I am only able to successfully see results for a few benchmarks.
I see issues with the following benchmarks:
md grid
md knn
spmv
stencil2d
stencil3d

Does anyone else see this issue?
Thanks,
Ronak

There might be an issue from the force update mechanism of the MD Grid implementation. Based on my understanding of MD, the new forces should all come out from the original input of the forces. However, the code implementation directly write the updated force to the original force vectors, leading to the fact that each force is calculated from some cells with updated forces and some cells with original forces. I was wondering if it is an issue on algorithm implementation.

Hi,

I would like to report a possible bug on the merge sort kernel implementation that may cause out-of-bound array access:

The stop variable is set to SIZE, which is the same size as the array being sorted. However, on line 12 here:

The loop upper bound is inclusive. When stop is set to SIZE, there will be an out-of-bound array access a[SIZE] which causes segfault.

I believe changing stop to SIZE-1 should fix it. Here's a Python implementation verified against Python's own sort function:

N = 5

def merge(a, start, m, stop):
    temp = np.zeros(N, dtype=np.int32)
    for i in range(start, m + 1):
        temp[i] = a[i]
    for j in range(m+1, stop + 1):
        temp[m + 1 + stop - j] = a[j]
    
    i = start
    j = stop
    for k in range(start, stop + 1):
        tmp_j = temp[j]
        tmp_i = temp[i]
        if (tmp_j < tmp_i):
            a[k] = tmp_j
            j -= 1
        else:
            a[k] = tmp_i
            i += 1

def mergesort_reference(a):
    start = 0
    stop = N - 1
    m = 1
    while m < stop-start + 1:
        for i in range(start, stop, m+m):
            f = i
            mid = i + m - 1
            to = i + m + m - 1
            if to < stop:
                merge(a, f, mid, to)
            else:
                merge(a, f, mid, stop)
        m += m
    return a

Our old data generator used rather lengthy headers for specifying training data and labels. We removed them, but the generator code still references their variables.

The right thing to do is create a synthetic training set by adding noise to a computable function. This would fix the undefined variable problems, and it would also enable backprop/backprop to work properly when the input_dimension and possible_outputs parameters are changed.

We utilized the VitisHLS 2020.2 tool for cosimulation and observed discrepancies in the cosimulation results of the Sort/Radix example (the direction we use is sort_dir). Following thorough debugging and analysis, we identified that the VitisHLS tool might have overlooked the read-after-write correlation between the local_scan and last_step_scan functions, resulting in premature updating of the value of bucket[0]. The ultimate successful solution involved explicitly incorporating the dependency of bucket[0]. We temporarily stored the value of bucket[0] at the conclusion of the hist execution and restored it at the onset of the local_scan execution. Some of the codes we modified are as follows:

void hist(int bucket[BUCKETSIZE], int a[SIZE], int exp)
{
    int blockID, i, bucket_indx, a_indx;
    blockID = 0;
    hist_1 : for (blockID=0; blockID<NUMOFBLOCKS; blockID++) {
        hist_2 : for(i=0; i<4; i++) {
            a_indx = blockID * ELEMENTSPERBLOCK + i;
            bucket_indx = ((a[a_indx] >> exp) & 0x3)*NUMOFBLOCKS + blockID + 1;
            bucket[bucket_indx]++;
        }
    }
    lastval=bucket[0];
}

void local_scan(int bucket[BUCKETSIZE])
{
    int radixID, i, bucket_indx;
    bucket[0]=lastval;
    local_1 : for (radixID=0; radixID<SCAN_RADIX; radixID++) {
        local_2 : for (i=1; i<SCAN_BLOCK; i++){
            bucket_indx = radixID*SCAN_BLOCK + i;
            bucket[bucket_indx] += bucket[bucket_indx-1];
        }
    }
}