bit4_t digitrec( digit input )
{
#include "training_data.h"
// This array stores K minimum distances per training set
bit6_t knn_set[10][K_CONST];
// Initialize the knn set
for ( int i = 0; i < 10; ++i )
for ( int k = 0; k < K_CONST; ++k )
// Note that the max distance is 49
knn_set[i][k] = 50;
L1800: for ( int i = 0; i < TRAINING_SIZE; ++i ) {
L10: for ( int j = 0; j < 10; j++ ) {
// Read a new instance from the training set
digit training_instance = training_data[j][i];
// Update the KNN set
update_knn( input, training_instance, knn_set[j] );
}
}
// Compute the final output
return knn_vote( knn_set );
}
void DigitRec(long * global_training_set, long * global_test_set, int* global_results) {
#pragma HLS INTERFACE m_axi port=global_training_set offset=slave bundle=gmem
#pragma HLS INTERFACE m_axi port=global_test_set offset=slave bundle=gmem
#pragma HLS INTERFACE m_axi port=global_results offset=slave bundle=gmem
#pragma HLS INTERFACE s_axilite port=global_training_set bundle=control
#pragma HLS INTERFACE s_axilite port=global_test_set bundle=control
#pragma HLS INTERFACE s_axilite port=global_results bundle=control
#pragma HLS INTERFACE s_axilite port=return bundle=control
// This array stores K minimum distances per training set
int knn_set[10][K_CONST];
#pragma HLS array_partition variable=knn_set complete dim=0
int i = 0;
int j = 0;
long training_set [TRAINING_SIZE][40] ;
#pragma HLS array_partition variable=training_set complete dim=2
//#pragma HLS array_partition variable=training_set complete dim=3
long test_set [TEST_SIZE][4];
#pragma HLS array_partition variable=test_set complete dim=2
int results [RESULT_SIZE];
for (i = 0; i < 10; i ++ )
{
for (j = 0; j < TRAINING_SIZE ; j ++ )
{
training_set[j][i*4+0] = global_training_set[4*i*TRAINING_SIZE+4*j + 0];
training_set[j][i*4+1] = global_training_set[4*i*TRAINING_SIZE+4*j + 1];
training_set[j][i*4+2] = global_training_set[4*i*TRAINING_SIZE+4*j + 2];
training_set[j][i*4+3] = global_training_set[4*i*TRAINING_SIZE+4*j + 3];
}
}
for ( i = 0; i < TEST_SIZE; ++i)
{
test_set[i][0] = global_test_set[i*4 + 0];
test_set[i][1] = global_test_set[i*4 + 1];
test_set[i][2] = global_test_set[i*4 + 2];
test_set[i][3] = global_test_set[i*4 + 3];
}
for (int t = 0; t < TEST_SIZE; ++t) {
// Initialize the knn set
for ( i = 0; i < 10 ; ++i )
{
for (j = 0; j < K_CONST; j ++ )
// Note that the max distance is 256
knn_set[i][j] = 256;
}
TRAINING_LOOP:
for ( i = 0; i < TRAINING_SIZE; ++i ) {
#pragma HLS pipeline
DIGIT_UNROLL:
for ( j = 0; j < 10; j++ ) {
#pragma HLS UNROLL factor=10
// Read a new instance from the training set
long training_instance[4];
training_instance[0] = training_set[i][j*4+0];
training_instance[1] = training_set[i][j*4+1];
training_instance[2] = training_set[i][j*4+2];
training_instance[3] = training_set[i][j*4+3];
// Update the KNN set
update_knn( test_set[t], training_instance, knn_set[j] );
}
}
// Compute the final output
results[t] = knn_vote(knn_set);
}
for ( i = 0; i < RESULT_SIZE; ++i) {
global_results[i] = results[i];
}
return;
}
