Primitive APIs in xf::database

aggregate

aggregate overload (1)

#include "xf_database/aggregate.hpp"

template <
    AggregateOp op,
    typename T
    >
void aggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <T>& out_strm,
    hls::stream <bool>& out_e_strm
    )

Overload for most common aggregations.

As shown below in the parameters, this function can calculate one of a range of statistics, including minimal, maximal, average (mean), variance, L1 norm, L2 norm. It can also calculate the sum and count.

The limitation in this function is that the output data type must match with the input data type. In some cases, the sum or count may overflow the output type, but it can be safely covered by other aggregation overloads.

Note that minimum, maximum, sum, count, number of non-zero, L1 norm as well as L2 norm aggregate functions will all be returned as zero when the input is empty.

For group-by aggregation, please refer to the hashGroupAggregateMPU primitive.

Parameters:

op	the aggregate operator: AOP_SUM, AOP_MAX, AOP_MIN, AOP_MEAN, AOP_VARIANCE, AOP_NORML1 or AOP_NORML2
T	the data type of input and output streams
in_strm	input data stream
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data

aggregate overload (2)

#include "xf_database/aggregate.hpp"

template <
    AggregateOp op,
    typename T,
    typename T2
    >
void aggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <T2>& out_strm,
    hls::stream <bool>& out_e_strm
    )

Aggregate function overload for SUM operation.

The output type can be inferred to be different from input type, this allows the sum value to have more precision bits than input, and avoid overflow.

Note that sum aggregate function will be returned as zero when the input is empty.

For group-by aggregation, please refer to the hashGroupAggregateMPU primitive.

Parameters:

op	the aggregate operator: AOP_SUM
T	the data type of input stream, inferred from argument
T2	the data type of output stream, inferred from argument
in_strm	input data stream
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data

aggregate overload (3)

#include "xf_database/aggregate.hpp"

template <
    AggregateOp op,
    typename T
    >
void aggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <uint64_t>& out_strm,
    hls::stream <bool>& out_e_strm
    )

Aggregate function overload for counting.

This function counts the number of input rows, or number of non-zero input rows, and returns the count as uint64_t value.

Note that count aggregate function will be returned as zero when the input is empty.

For group-by aggregation, please refer to the hashGroupAggregateMPU primitive.

Parameters:

op	the aggregate operator: AOP_COUNT or AOP_COUNTNONZEROS
T	the data type of input stream, inferred from argument
in_strm	input data stream
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data

bitonicSort

#include "xf_database/bitonic_sort.hpp"

template <
    typename Key_Type,
    int BitonicSortNumber
    >
void bitonicSort (
    hls::stream <Key_Type>& kin_strm,
    hls::stream <bool>& kin_strm_end,
    hls::stream <Key_Type>& kout_strm,
    hls::stream <bool>& kout_strm_end,
    bool order
    )

Bitonic sort is parallel algorithm for sorting.

This algorithms can sort a large vector of data in parallel, and by cascading the sorters into a network it can offer good theoretical throughput.

Although this algorithms is suitable for FPGA acceleration, it does not work well with the row-by-row streaming interface in database library. Please consider this primitive as a demo, and only use it by deriving from this code. Alternative sorting algorithms in this library are insertSort and mergeSort .

Parameters:

Key_Type	the input and output key type
BitonicSortNumber	the parallel number
kin_strm	input key stream
kin_strm_end	end flag stream for input key
kout_strm	output key stream
kout_strm_end	end flag stream for output key
order	1 for ascending or 0 for descending sort

bfGen

#include "xf_database/bloom_filter.hpp"

template <
    bool IS_BRAM,
    int STR_IN_W,
    int BV_W
    >
void bfGen (
    hls::stream <ap_uint <STR_IN_W>>& msg_strm,
    hls::stream <bool>& in_e_strm,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr0,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr1,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr2
    )

Generate the bloomfilter in on-chip RAM blocks.

This primitive calculates hash of input values, and marks corresponding bits in the on-chip RAM blocks. RAM blocks can be configured to be 18-bit BRAM or 72-bit URAM.

The bloom-filter bit vectors are passed as three pointers, and behind the scene, one hash value is calculated and manipulated into three distint marker locatins in these vectors.

To check for existance of a value with generated vector, use the bfCheck primitive.

Parameters:

STR_IN_W	W width of the streamed input message, e.g., W=512.
BV_W	width of the hash value. ptr0, ptr1 and ptr2 should point at MEM_SPACE=2^BV_W (bit).
msg_strm	input message stream.
in_e_strm	the flag that indicate the end of input message stream.
bit_vector_ptr0	the pointer of bit_vector0.
bit_vector_ptr1	the pointer of bit_vector1.
bit_vector_ptr2	the pointer of bit_vector2.

bfGenStream

#include "xf_database/bloom_filter.hpp"

template <
    bool IS_BRAM,
    int STR_IN_W,
    int BV_W
    >
void bfGenStream (
    hls::stream <ap_uint <STR_IN_W>>& msg_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <IS_BRAM?16:64>>& bit_vet_strm,
    hls::stream <bool>& out_e_strm
    )

Generate the bloomfilter in on-chip RAM blocks, and emit the vectors upon finish.

This primitive calculates hash values of input, and marks corresponding bits in the on-chip RAM blocks. RAM blocks can be configured to be 18-bit BRAM or 72-bit URAM.

The bloom-filter bit vectors are built into internally allocated buffers, and streamed out after the filter has been fully built.

Parameters:

STR_IN_W	W width of the streamed input message, e.g., W=512.
BV_W	width of the hash value. bit_vet_strm should send out MEM_SPACE=2^BV_W (bit) data in total.
msg_strm	input message stream.
in_e_strm	the flag that indicate the end of input message stream.
bit_vet_strm	the output stream of bit_vector.
out_e_strm	the flag that indicate the end of output stream.

bfCheck

#include "xf_database/bloom_filter.hpp"

template <
    bool IS_BRAM,
    int STR_IN_W,
    int BV_W
    >
void bfCheck (
    hls::stream <ap_uint <STR_IN_W>>& msg_strm,
    hls::stream <bool>& in_e_strm,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr0,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr1,
    ap_uint <IS_BRAM?16:72>* bit_vector_ptr2,
    hls::stream <bool>& out_v_strm,
    hls::stream <bool>& out_e_strm
    )

Check existance of value using bloom-filter vectors.

This primitive is designed to work with the bloom-filter vectors generated by the bfGen primitive. Basically, it detects the existance of value by hashing it and check for the corresponding vector bits. When hit, it is likely to be in the set of generating values, otherwise, it cannot be element of the set. RAM blocks can be configured to be 18-bit BRAM or 72-bit URAM, the setting must match bfGen .

Parameters:

IS_BRAM	choose which types of memory to use. True for BRAM. False for URAM
STR_IN_W	W width of the streamed input message, e.g., W=512.
BV_W	width of the hash value. ptr0, ptr1 and ptr2 should point at MEM_SPACE=2^BV_W (bit).
msg_strm	input message stream.
in_e_strm	the flag that indicate the end of input message stream.
bit_vector_ptr0	the pointer of bit_vector0.
bit_vector_ptr1	the pointer of bit_vector1.
bit_vector_ptr2	the pointer of bit_vector2.
out_v_strm	the output stream that indicate whether the value may exist <1 for true, 0 for false>.
out_e_strm	the output end flag stream.

combineCol

combineCol overload (1)

#include "xf_database/combine_split_col.hpp"

template <
    int _WCol1,
    int _WCol2,
    int _WColOut
    >
void combineCol (
    hls::stream <ap_uint <_WCol1>>& din1_strm,
    hls::stream <ap_uint <_WCol2>>& din2_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WColOut>>& dout_strm,
    hls::stream <bool>& out_e_strm
    )

Combines two columns into one.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the combine column primitive fuses data of same row but different columns into one wide column.

The counter part of this primitive is splitCol .

Parameters:

_WCol1	the width of 1st input stream.
_WCol2	the width of 2nd input stream.
_WColOut	the width of output stream.
din1_strm	1st input data stream.
din2_strm	2nd input data stream.
in_e_strm	end flag stream for input data.
dout_strm	output data stream.
out_e_strm	end flag stream for output data.

combineCol overload (2)

#include "xf_database/combine_split_col.hpp"

template <
    int _WCol1,
    int _WCol2,
    int _WCol3,
    int _WColOut
    >
void combineCol (
    hls::stream <ap_uint <_WCol1>>& din1_strm,
    hls::stream <ap_uint <_WCol2>>& din2_strm,
    hls::stream <ap_uint <_WCol3>>& din3_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WColOut>>& dout_strm,
    hls::stream <bool>& out_e_strm
    )

Combines three columns into one.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the combine column primitive fuses data of same row but different columns into one wide column.

The counter part of this primitive is splitCol .

Parameters:

_WCol1	the width of 1st input stream.
_WCol2	the width of 2nd input stream.
_WCol3	the width of 3rd input stream.
_WColOut	the width of output stream.
din1_strm	1st input data stream.
din2_strm	2nd input data stream.
din3_strm	3rd input data stream.
in_e_strm	end flag stream for input data.
dout_strm	output data stream.
out_e_strm	end flag stream for output data.

combineCol overload (3)

#include "xf_database/combine_split_col.hpp"

template <
    int _WCol1,
    int _WCol2,
    int _WCol3,
    int _WCol4,
    int _WColOut
    >
void combineCol (
    hls::stream <ap_uint <_WCol1>>& din1_strm,
    hls::stream <ap_uint <_WCol2>>& din2_strm,
    hls::stream <ap_uint <_WCol3>>& din3_strm,
    hls::stream <ap_uint <_WCol4>>& din4_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WColOut>>& dout_strm,
    hls::stream <bool>& out_e_strm
    )

Combines four columns into one.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the combine column primitive fuses data of same row but different columns into one wide column.

The counter part of this primitive is splitCol .

Parameters:

_WCol1	the width of 1st input stream.
_WCol2	the width of 2nd input stream.
_WCol3	the width of 3rd input stream.
_WCol4	the width of 4th input stream.
_WColOut	the width of output stream.
din1_strm	1st input data stream.
din2_strm	2nd input data stream.
din3_strm	3rd input data stream.
din4_strm	4th input data stream.
in_e_strm	end flag stream for input data.
dout_strm	output data stream.
out_e_strm	end flag stream for output data.

combineCol overload (4)

#include "xf_database/combine_split_col.hpp"

template <
    int _WCol1,
    int _WCol2,
    int _WCol3,
    int _WCol4,
    int _WCol5,
    int _WColOut
    >
void combineCol (
    hls::stream <ap_uint <_WCol1>>& din1_strm,
    hls::stream <ap_uint <_WCol2>>& din2_strm,
    hls::stream <ap_uint <_WCol3>>& din3_strm,
    hls::stream <ap_uint <_WCol4>>& din4_strm,
    hls::stream <ap_uint <_WCol5>>& din5_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WColOut>>& dout_strm,
    hls::stream <bool>& out_e_strm
    )

Combines five columns into one.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the combine column primitive fuses data of same row but different columns into one wide column.

The counter part of this primitive is splitCol .

Parameters:

_WCol1	the width of 1st input stream.
_WCol2	the width of 2nd input stream.
_WCol3	the width of 3rd input stream.
_WCol4	the width of 4th input stream.
_WCol5	the width of 5th input stream.
_WColOut	the width of output stream.
din1_strm	1st input data stream.
din2_strm	2nd input data stream.
din3_strm	3rd input data stream.
din4_strm	4th input data stream.
din5_strm	5th input data stream.
in_e_strm	end flag stream for input data.
dout_strm	output data stream.
out_e_strm	end flag stream for output data.

splitCol

splitCol overload (1)

#include "xf_database/combine_split_col.hpp"

template <
    int _WColIn,
    int _WCol1,
    int _WCol2
    >
void splitCol (
    hls::stream <ap_uint <_WColIn>>& din_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WCol1>>& dout1_strm,
    hls::stream <ap_uint <_WCol2>>& dout2_strm,
    hls::stream <bool>& out_e_strm
    )

Split previously combined columns into two.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the split column primitive breaks the wide output stream into independent column-specific streams.

The counter part of this primitive is combineCol .

Parameters:

_WColIn	the width of input stream.
_WCol1	the width of 1st output stream.
_WCol2	the width of 2nd output stream.
din_strm	input data stream.
in_e_strm	end flag stream for input data.
dout1_strm	1st output data stream.
dout2_strm	2nd output data stream.
out_e_strm	end flag stream for output data.

splitCol overload (2)

#include "xf_database/combine_split_col.hpp"

template <
    int _WColIn,
    int _WCol1,
    int _WCol2,
    int _WCol3
    >
void splitCol (
    hls::stream <ap_uint <_WColIn>>& din_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WCol1>>& dout1_strm,
    hls::stream <ap_uint <_WCol2>>& dout2_strm,
    hls::stream <ap_uint <_WCol3>>& dout3_strm,
    hls::stream <bool>& out_e_strm
    )

Split previously combined columns into three.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the split column primitive breaks the wide output stream into independent column-specific streams.

The counter part of this primitive is combineCol .

Parameters:

_WColIn	the width of input stream.
_WCol1	the width of 1st output stream.
_WCol2	the width of 2nd output stream.
_WCol3	the width of 3rd output stream.
din_strm	input data stream
in_e_strm	end flag stream for input data
dout1_strm	1st output data stream
dout2_strm	2nd output data stream
dout3_strm	3rd output data stream
out_e_strm	end flag stream for output data

splitCol overload (3)

#include "xf_database/combine_split_col.hpp"

template <
    int _WColIn,
    int _WCol1,
    int _WCol2,
    int _WCol3,
    int _WCol4
    >
void splitCol (
    hls::stream <ap_uint <_WColIn>>& din_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WCol1>>& dout1_strm,
    hls::stream <ap_uint <_WCol2>>& dout2_strm,
    hls::stream <ap_uint <_WCol3>>& dout3_strm,
    hls::stream <ap_uint <_WCol4>>& dout4_strm,
    hls::stream <bool>& out_e_strm
    )

Split previously combined columns into four.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the split column primitive breaks the wide output stream into independent column-specific streams.

The counter part of this primitive is combineCol .

Parameters:

_WColIn	the width of input stream.
_WCol1	the width of 1st output stream.
_WCol2	the width of 2nd output stream.
_WCol3	the width of 3rd output stream.
_WCol4	the width of 4th output stream.
din_strm	input data stream
in_e_strm	end flag stream for input data
dout1_strm	1st output data stream
dout2_strm	2nd output data stream
dout3_strm	3rd output data stream
dout4_strm	4th output data stream
out_e_strm	end flag stream for output data

splitCol overload (4)

#include "xf_database/combine_split_col.hpp"

template <
    int _WColIn,
    int _WCol1,
    int _WCol2,
    int _WCol3,
    int _WCol4,
    int _WCol5
    >
void splitCol (
    hls::stream <ap_uint <_WColIn>>& din_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <_WCol1>>& dout1_strm,
    hls::stream <ap_uint <_WCol2>>& dout2_strm,
    hls::stream <ap_uint <_WCol3>>& dout3_strm,
    hls::stream <ap_uint <_WCol4>>& dout4_strm,
    hls::stream <ap_uint <_WCol5>>& dout5_strm,
    hls::stream <bool>& out_e_strm
    )

Split previously combined columns into five.

Columns are passed through streams of certain width in hardware. Normally, each column uses one stream, but for some primitives, the processing semantic abstract the columns into a couple of groups, and trait each group as a whole. To make calling such primitives easier, the split column primitive breaks the wide output stream into independent column-specific streams.

The counter part of this primitive is combineCol .

Parameters:

_WColIn	the width of input stream.
_WCol1	the width of 1st output stream.
_WCol2	the width of 2nd output stream.
_WCol3	the width of 3rd output stream.
_WCol4	the width of 4th output stream.
_WCol5	the width of 5th output stream.
din_strm	input data stream
in_e_strm	end flag stream for input data
dout1_strm	1st output data stream
dout2_strm	2nd output data stream
dout3_strm	3rd output data stream
dout4_strm	4th output data stream
dout5_strm	5th output data stream
out_e_strm	end flag stream for output data

compoundSort

#include "xf_database/compound_sort.hpp"

template <
    typename KEY_TYPE,
    int SORT_LEN,
    int INSERT_LEN
    >
void compoundSort (
    bool order,
    hls::stream <KEY_TYPE>& inKeyStrm,
    hls::stream <bool>& inEndStrm,
    hls::stream <KEY_TYPE>& outKeyStrm,
    hls::stream <bool>& outEndStrm
    )

compoundSort sort the key based on insert sort and merge sort.

Parameters:

KEY_TYPE	key type
SORT_LEN	Maximum support sort length, between 16K to 2M, but it must be an integer power of 2.
INSERT_LEN	insert sort length, maximum length 1024 (recommend)
order	1:sort ascending 0:sort descending
inKeyStrm	input key stream
inEndStrm	end flag stream for input key
outKeyStrm	output key-sorted stream
outEndStrm	end flag stream for output key

directGroupAggregate

directGroupAggregate overload (1)

#include "xf_database/direct_group_aggregate.hpp"

template <
    int op,
    int DATINW,
    int DATOUTW,
    int DIRECTW
    >
void directGroupAggregate (
    hls::stream <ap_uint <DATINW>>& vin_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <DATOUTW>>& vout_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <ap_uint <DIRECTW>>& kin_strm,
    hls::stream <ap_uint <DIRECTW>>& kout_strm
    )

Group-by aggregation with limited key width.

This primitive is suitable for scenario in which the width of group key is limited, so that a on-chip array directly addressed by the key can be created to store the aggregation value. The total storage required is row size * (2 ^ key width) .

The following aggregate operators are supported:

• AOP_MAX
• AOP_MIN
• AOP_SUM
• AOP_COUNT
• AOP_MEAN
• AOP_VARIANCE
• AOP_NORML1
• AOP_NORML2

The return value is typed the same as the input payload value.

Caution

Attention should be paid for overflow in sum or count.

Parameters:

op	the aggregate operator, as defined in AggregateOp enum.
DATINW	the width of input payload
DATOUTW	the width of output aggr-payload
DIRECTW	the width of input and output key
vin_strm	value input
in_e_strm	end flag stream for input data
vout_strm	value output
out_e_strm	end flag stream for output data
kin_strm	group-by key input
kout_strm	group-by key output

directGroupAggregate overload (2)

#include "xf_database/direct_group_aggregate.hpp"

template <
    int DATINW,
    int DATOUTW,
    int DIRECTW
    >
void directGroupAggregate (
    ap_uint <32> op,
    hls::stream <ap_uint <DATINW>>& vin_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <ap_uint <DATOUTW>>& vout_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <ap_uint <DIRECTW>>& kin_strm,
    hls::stream <ap_uint <DIRECTW>>& kout_strm
    )

Group-by aggregation with limited key width, runtime programmable.

This primitive is suitable for scenario in which the width of group key is limited, so that a on-chip array directly addressed by the key can be created to store the aggregation value. The total storage required is row size * (2 ^ key width) .

The following aggregate operators are supported:

• AOP_MAX
• AOP_MIN
• AOP_SUM
• AOP_COUNT
• AOP_MEAN
• AOP_NORM1

The return value is typed the same as the input payload value.

Caution

Attention should be paid for overflow in sum or count.

Parameters:

DATINW	the width of input payload
DATOUTW	the width of output aggr-payload
DIRECTW	the width of input and output key
op	the aggregate operator, as defined in AggregateOp enum.
vin_strm	value input
in_e_strm	end flag stream for input data
vout_strm	value output
out_e_strm	end flag stream for output data
kin_strm	group-by key input
kout_strm	group-by key output

duplicateCol

#include "xf_database/duplicate_col.hpp"

template <int W>
void duplicateCol (
    hls::stream <ap_uint <W>>& d_in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <ap_uint <W>>& d0_out_strm,
    hls::stream <ap_uint <W>>& d1_out_strm,
    hls::stream <bool>& e_out_strm
    )

Duplicate one column into two columns.

Parameters:

W	column data width in bits.
d_in_strm	input data stream.
e_in_strm	end flag for input data.
d0_out_strm	output data stream 0.
d1_out_strm	output data stream 1.
e_out_strm	end flag for output data.

dynamicEval

#include "xf_database/dynamic_eval.hpp"

template <
    typename TStrm1,
    typename TStrm2,
    typename TStrm3,
    typename TStrm4,
    typename TConst1,
    typename TConst2,
    typename TConst3,
    typename TConst4,
    typename TOut
    >
void dynamicEval (
    ap_uint <289> config,
    hls::stream <TStrm1>& strm_in1,
    hls::stream <TStrm2>& strm_in2,
    hls::stream <TStrm3>& strm_in3,
    hls::stream <TStrm4>& strm_in4,
    hls::stream <bool>& strm_in_end,
    hls::stream <TOut>& strm_out,
    hls::stream <bool>& strm_out_end
    )

Dynamic expression evaluation.

This primitive has four fixed number of column inputs, and allows up to four constants to be specified via configuration. The operation between the column values and constants can be defined dynamically through the configuration at run-time. The same configuration is used for all rows until the end of input.

The constant numbers are assumed to be no more than 32-bits.

For the definition of the config word, please refer to the “Design Internal” Section of the document and the corresponding test in L1/tests .

Parameters:

TStrm1	Type of input Stream1
TStrm2	Type of input Stream2
TStrm3	Type of input Stream3
TStrm4	Type of input Stream4
TConst1	Type of input Constant1
TConst2	Type of input Constant2
TConst3	Type of input Constant3
TConst4	Type of input Constant4
TOut	Type of Compute Result
config	configuration bits of ops and constants.
strm_in1	input Stream1
strm_in2	input Stream2
strm_in3	input Stream3
strm_in4	input Stream4
strm_in_end	end flag of input stream
strm_out	output Stream
strm_out_end	end flag of output stream

dynamicFilter

dynamicFilter overload (1)

#include "xf_database/dynamic_filter.hpp"

template <
    int W,
    int WP
    >
void dynamicFilter (
    hls::stream <ap_uint <32>>& filter_cfg_strm,
    hls::stream <ap_uint <W>>& v0_strm,
    hls::stream <ap_uint <W>>& v1_strm,
    hls::stream <ap_uint <W>>& v2_strm,
    hls::stream <ap_uint <W>>& v3_strm,
    hls::stream <ap_uint <WP>>& pay_in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <ap_uint <WP>>& pay_out_strm,
    hls::stream <bool>& e_pay_out_strm
    )

Filter payloads according to conditions set during run-time.

This primitive, with its 3 overloads, supports filtering rows using up to four columns as conditions. The payload columns should be grouped together into this primitive, using combineCol primitive, and its total width is not explicitly limited (but naturally bound by resources).

The filter conditions consists of whether each of the conditions is within a given range, and relations between any two conditions. The configuration is set once before processing the rows, and reused until the last row. For configuration generation, please refer to the “Design Internals” Section of the document and corresponding test case of this primitive.

Parameters:

W	width of all condition column streams, in bits.
WP	width of payload column, in bits.
filter_cfg_strm	stream of raw config bits for this primitive.
v0_strm	condition column stream 0.
v1_strm	condition column stream 1.
v2_strm	condition column stream 2.
v3_strm	condition column stream 3.
pay_in_strm	payload input stream.
e_in_strm	end flag stream for input table.
pay_out_strm	payload output stream.
e_pay_out_strm	end flag stream for payload output.

dynamicFilter overload (2)

#include "xf_database/dynamic_filter.hpp"

template <
    int W,
    int WP
    >
void dynamicFilter (
    hls::stream <ap_uint <32>>& filter_cfg_strm,
    hls::stream <ap_uint <W>>& v0_strm,
    hls::stream <ap_uint <W>>& v1_strm,
    hls::stream <ap_uint <W>>& v2_strm,
    hls::stream <ap_uint <WP>>& pay_in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <ap_uint <WP>>& pay_out_strm,
    hls::stream <bool>& e_pay_out_strm
    )

Filter payloads according to conditions set during run-time.

This function is a wrapper-around the four-condition-column dynamic_filter, just duplicating the columns to feed all its inputs. Thus they share the same configuration bit pattern. All op related to the 4th column should be set to FOP_DC .

Parameters:

W	width of all condition column streams, in bits.
WP	width of payload column, in bits.
filter_cfg_strm	stream of raw config bits for this primitive.
v0_strm	condition column stream 0.
v1_strm	condition column stream 1.
v2_strm	condition column stream 2.
pay_in_strm	payload input stream.
e_in_strm	end flag stream for input table.
pay_out_strm	payload output stream.
e_pay_out_strm	end flag stream for payload output.

dynamicFilter overload (3)

#include "xf_database/dynamic_filter.hpp"

template <
    int W,
    int WP
    >
void dynamicFilter (
    hls::stream <ap_uint <32>>& filter_cfg_strm,
    hls::stream <ap_uint <W>>& v0_strm,
    hls::stream <ap_uint <W>>& v1_strm,
    hls::stream <ap_uint <WP>>& pay_in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <ap_uint <WP>>& pay_out_strm,
    hls::stream <bool>& e_pay_out_strm
    )

Filter payloads according to conditions set during run-time.

This function is a wrapper-around the four-condition-column dynamic_filter, just duplicating the columns to feed all its inputs. Thus they share the same configuration bit pattern. All op related to the 3rd and 4th columns should be set to FOP_DC .

Parameters:

W	width of all condition column streams, in bits.
WP	width of payload column, in bits.
filter_cfg_strm	stream of raw config bits for this primitive.
v0_strm	condition column stream 0.
v1_strm	condition column stream 1.
pay_in_strm	payload input stream.
e_in_strm	end flag stream for input table.
pay_out_strm	payload output stream.
e_pay_out_strm	end flag stream for payload output.

dynamicFilter overload (4)

#include "xf_database/dynamic_filter.hpp"

template <
    int W,
    int WP
    >
void dynamicFilter (
    hls::stream <ap_uint <32>>& filter_cfg_strm,
    hls::stream <ap_uint <W>>& v0_strm,
    hls::stream <ap_uint <WP>>& pay_in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <ap_uint <WP>>& pay_out_strm,
    hls::stream <bool>& e_pay_out_strm
    )

Filter payloads according to conditions set during run-time.

This function is a wrapper-around the four-condition-column dynamic_filter, just duplicating the columns to feed all its inputs. Thus they share the same configuration bit pattern. All op related to the 2nd to 4th columns should be set to FOP_DC .

Parameters:

W	width of all condition column streams, in bits.
WP	width of payload column, in bits.
filter_cfg_strm	stream of raw config bits for this primitive.
v0_strm	condition column stream 0.
pay_in_strm	payload input stream.
e_in_strm	end flag stream for input table.
pay_out_strm	payload output stream.
e_pay_out_strm	end flag stream for payload output.

groupAggregate

groupAggregate overload (1)

#include "xf_database/group_aggregate.hpp"

template <
    AggregateOp op,
    typename T,
    typename KEY_T
    >
void groupAggregate (
    hls::stream <T>& din_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <T>& dout_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <KEY_T>& kin_strm,
    hls::stream <KEY_T>& kout_strm
    )

group aggregate function that returns same type as input

Parameters:

op	the aggregate operator: AOP_MAX, AOP_MIN, AOP_MEAN, AOP_VARIANCE, AOP_NORML1 or AOP_NORML2
T	the data type of input and output streams
KEY_T	the input and output indexing key type
din_strm	input data stream
in_e_strm	end flag stream for input data
dout_strm	output data stream
out_e_strm	end flag stream for output data
kin_strm	input indexing key stream
kout_strm	output indexing key stream

groupAggregate overload (2)

#include "xf_database/group_aggregate.hpp"

template <
    AggregateOp op,
    typename T,
    typename T2,
    typename KEY_T
    >
void groupAggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <T2>& out_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <KEY_T>& kin_strm,
    hls::stream <KEY_T>& kout_strm
    )

group aggregate function that returns different type as input

Parameters:

op	the aggregate operator: AOP_SUM
T	the input stream type, inferred from argument
T2	the output stream type, inferred from argument
KEY_T	the input and output stream type, inferred from argument
in_strm	input data stream
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data
kin_strm	input indexing key stream
kout_strm	output indexing key stream

groupAggregate overload (3)

#include "xf_database/group_aggregate.hpp"

template <
    AggregateOp op,
    typename T,
    typename KEY_T
    >
void groupAggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <uint64_t>& out_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <KEY_T>& kin_strm,
    hls::stream <KEY_T>& kout_strm
    )

aggregate function that counts and returns uint64_t

Parameters:

op	the aggregate operator: AOP_COUNT or AOP_COUNTNONZEROS
T	the input stream type, inferred from argument
KEY_T	the input and output stream type, inferred from argument
in_strm	input data stream
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data
kin_strm	input indexing key stream
kout_strm	output indexing key stream

groupAggregate overload (4)

#include "xf_database/group_aggregate.hpp"

template <
    AggregateOp op,
    typename T,
    typename KEY_T
    >
void groupAggregate (
    hls::stream <T>& in_strm,
    hls::stream <bool>& isnull_strm,
    hls::stream <bool>& in_e_strm,
    hls::stream <uint64_t>& out_strm,
    hls::stream <bool>& out_e_strm,
    hls::stream <KEY_T>& kin_strm,
    hls::stream <KEY_T>& kout_strm
    )

aggregate function that counts and returns uint64_t

Parameters:

op	the aggregate operator: AOP_COUNT
T	the input stream type, inferred from argument
KEY_T	the input and output stream type, inferred from argument
in_strm	input data stream
isnull_strm	flag to indicate the input data is null or not
in_e_strm	end flag stream for input data
out_strm	output data stream
out_e_strm	end flag stream for output data
kin_strm	input indexing key stream
kout_strm	output indexing key stream

hashAntiJoin

#include "xf_database/hash_anti_join.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM
    >
void hashAntiJoin (
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Multi-PU Hash-Anti-Join primitive, using multiple DDR/HBM buffers.

This primitive shares most of the structure of hashJoinV3 , but performs anti-join instead of inner-join. Both inner and outer table should be send to this primitve once, starting with the inner table.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, larger than 24 is suggested.
CH_NM	number of input channels, 1,2,4.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	the 1st element is the depth of each hash, the 2nd element is joined number
pu_end_status_strms
j_strm	output of joined result
j_e_strm	end flag of joined result

hashGroupAggregate

#include "xf_database/hash_group_aggregate.hpp"

template <
    int _WKey,
    int _KeyNM,
    int _WPay,
    int _PayNM,
    int _HashMode,
    int _WHashHigh,
    int _WHashLow,
    int _CHNM,
    int _Wcnt,
    int _WBuffer,
    int _BurstLenW = 32,
    int _BurstLenR = 32
    >
void hashGroupAggregate (
    hls::stream <ap_uint <_WKey>> strm_key_in [_CHNM][_KeyNM],
    hls::stream <ap_uint <_WPay>> strm_pld_in [_CHNM][_PayNM],
    hls::stream <bool> strm_e_in [_CHNM],
    hls::stream <ap_uint <32>>& config,
    hls::stream <ap_uint <32>>& result_info,
    ap_uint <_WBuffer>* ping_buf0,
    ap_uint <_WBuffer>* ping_buf1,
    ap_uint <_WBuffer>* ping_buf2,
    ap_uint <_WBuffer>* ping_buf3,
    ap_uint <_WBuffer>* pong_buf0,
    ap_uint <_WBuffer>* pong_buf1,
    ap_uint <_WBuffer>* pong_buf2,
    ap_uint <_WBuffer>* pong_buf3,
    hls::stream <ap_uint <_WKey>> aggr_key_out [_KeyNM],
    hls::stream <ap_uint <_WPay>> aggr_pld_out [3][_PayNM],
    hls::stream <bool>& strm_e_out
    )

Generic hash group aggregate primitive.

With this primitive, the max number of lines of aggregate table is bound by the AXI buffer size.

The group aggregation values are updated inside the chip, and when a hash-bucket overflows, the overflowed rows are spilled into external buffers. The overflow buffer will be automatically re-scanned, and within each round, a number of distinct groups will be aggregated and emitted. This algorithm ends when the overflow buffer is empty and all groups are aggregated.

Attention

1. This module can accept multiple input row of key and payload pair per cycle.
2. The max distinct groups aggregated in one pass is 2 ^ (1 + _WHash).
3. When the width of the input stream is not fully used, data should be aligned to the little-end.
4. It is highly recommended to assign the ping buffer and pong buffer in different HBM banks, input and output in different DDR banks for a better performance.
5. The max number of lines of aggregate table cannot bigger than the max DDR/HBM SIZE used in this design.
6. When the bit-width of group key is known to be small, say 10-bit, please consider the directAggregate primitive, which offers smaller utilization, and requires no external buffer access.

Parameters:

_WKey	width of key, in bit.
_KeyNM	maximum number of key column, maximum is 8.
_WPay	width of max payload, in bit.
_PayNM	maximum number of payload column, maximum is 8.
_HashMode	control hash algotithm, 0: radix 1: lookup3.
_WHashHigh	number of hash bits used for dispatch pu.
_WHashLow	number of hash bits used for hash-table.
_CHNM	number of input channels.
_WBuffer	width of HBM/DDR buffer(ping_buf and pong_buf).
_BurstLenW	burst len of writting unhandled data.
_BurstLenR	burst len of reloading unhandled data.
strm_key_in	input of key streams.
strm_pld_in	input of payload streams.
strm_e_in	input of end signal.
config	information for initializing primitive, contains op for maximum of 8 columns, key column number(less than 8), pld column number(less than 8) and initial aggregate cnt.
result_info	result information at kernel end, contains op, key_column, pld_column and aggregate result cnt
ping_buf0	DDR/HBM ping buffer for unhandled data.
ping_buf1	DDR/HBM ping buffer for unhandled data.
ping_buf2	DDR/HBM ping buffer for unhandled data.
ping_buf3	DDR/HBM ping buffer for unhandled data.
pong_buf0	DDR/HBM pong buffer for unhandled data.
pong_buf1	DDR/HBM pong buffer for unhandled data.
pong_buf2	DDR/HBM pong buffer for unhandled data.
pong_buf3	DDR/HBM pong buffer for unhandled data.
aggr_key_out	output of key columns.
aggr_pld_out	output of pld columns. [0][*] is the result of min/max/cnt for pld columns, [1][*] is the low-bit value of sum/average, [2][*] is the hight-bit value of sum/average.
strm_e_out	is the end signal of output.

hashJoinMPU

hashJoinMPU overload (1)

#include "xf_database/hash_join_v2.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int BFW,
    int CH_NM,
    int BF_W,
    int EN_BF
    >
static void hashJoinMPU (
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <BFW>* stb0_buf,
    ap_uint <BFW>* stb1_buf,
    ap_uint <BFW>* stb2_buf,
    ap_uint <BFW>* stb3_buf,
    ap_uint <BFW>* stb4_buf,
    ap_uint <BFW>* stb5_buf,
    ap_uint <BFW>* stb6_buf,
    ap_uint <BFW>* stb7_buf,
    hls::stream <ap_uint <S_PW+B_PW>>& j1_strm,
    hls::stream <bool>& e5_strm
    )

Multi-PU Hash-Join primitive, using multiple DDR/HBM buffers.

The max number of lines of small table is 2M in this design. It is assumed that the hash-conflict is within 512 per bin.

This module can accept more than 1 input row per cycle, via multiple input channels. The small table and the big table shares the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. The small table should be fed TWICE, followed by the big table once.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, log2(small table max num of rows).
BFW	width of buffer.
CH_NM	number of input channels, 1,2,4.
BF_W	bloom-filter hash width.
EN_BF	bloom-filter switch, 0 for off, 1 for on.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
j1_strm	output of joined rows.
e5_strm	end signal of joined rows.

hashJoinMPU overload (2)

#include "xf_database/hash_join_v2.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int BFW,
    int CH_NM
    >
void hashJoinMPU (
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <BFW>* stb0_buf,
    ap_uint <BFW>* stb1_buf,
    ap_uint <BFW>* stb2_buf,
    ap_uint <BFW>* stb3_buf,
    ap_uint <BFW>* stb4_buf,
    ap_uint <BFW>* stb5_buf,
    ap_uint <BFW>* stb6_buf,
    ap_uint <BFW>* stb7_buf,
    hls::stream <ap_uint <S_PW+B_PW>>& j1_strm,
    hls::stream <bool>& e5_strm
    )

Multi-PU Hash-Join primitive, using multiple DDR/HBM buffers.

The max number of lines of small table is 8M in this design. It is assumed that the hash-conflict is within 512 per bin.

This module can accept more than 1 input row per cycle, via multiple input channels. The small table and the big table shares the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. The small table should be fed TWICE, followed by the big table once.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, log2(small table max num of rows).
BFW	width of buffer.
CH_NM	number of input channels, 1,2,4.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
j1_strm	output of joined rows.
e5_strm	end signal of joined rows.

hashJoinV3

#include "xf_database/hash_join_v3.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM
    >
void hashJoinV3 (
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Hash-Join v3 primitive, it takes more resourse than hashJoinMPU and promises a better performance in large size of table.

The maximum size of small table is 256MBx8(HBM number)=2GB in this design. The total hash entries is equal to 1<<(HASHWH + HASHWL), and it is limitied to maximum of 1M entries because of the size of URAM in a single SLR.

This module can accept more than 1 input row per cycle, via multiple input channels. The small table and the big table shares the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. To be different with hashJoinMPU , the small table and big table should be fed only once.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, larger than 24 is suggested.
CH_NM	number of input channels, 1,2,4.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	contains hash depth, row number of join result
pu_end_status_strms	contains hash depth, row number of join result
j_strm	output of joined result
j_e_strm	end flag of joined result

hashBuildProbeV3

#include "xf_database/hash_join_v3.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM,
    int BF_W,
    int EN_BF
    >
static void hashBuildProbeV3 (
    bool& build_probe_flag,
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Hash-Build-Probe v3 primitive, it can perform hash build and hash probe separately. It needs two call of kernel to perform build and probe seperately. There is a control flag to decide buld or probe. This primitive supports multiple build and mutiple probe, for example, you can scadule a workflow as: build0->build1->probe0->probe1->build2->build3->probe3…

The maximum size of small table is 256MBx8=2GB in this design. The total hash entries is equal to 1<<(HASHWH + HASHWL), and it is limitied to maximum of 1M entries because of the size of URAM in a single SLR.

This module can accept more than 1 input row per cycle, via multiple input channels. The small table and the big table shares the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. The small table and big table should be fed only ONCE.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, log2(small table max num of rows).
CH_NM	number of input channels, 1,2,4.
BF_W	bloom-filter hash width.
EN_BF	bloom-filter switch, 0 for off, 1 for on.
build_probe_flag	0:build 1:probe
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	contains build id, fixed hash depth, joined number of last probe and start addr of unused stb_buf for each PU
pu_end_status_strms	returns next build id, fixed hash depth, joined number of current probe and end addr of used stb_buf for each PU
j_strm	output of joined result
j_e_strm	end flag of joined result

hashJoinV4

#include "xf_database/hash_join_v4.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM,
    int BF_HASH_NM,
    int BFW,
    bool EN_BF
    >
static void hashJoinV4 (
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Hash-Join v4 primitive, using bloom filter to enhance performance of hash join.

The build and probe procedure is similar to which in hashJoinV3 , and this primitive adds a bloom filter to reduce the redundant access to HBM.

The maximum size of small table is 256MBx8=2GB in this design. The total hash entries is equal to 1<<(HASHWH + HASHWL), and it is limitied to maximum of 1M entries because of the size of URAM in a single SLR.

This module can accept more than 1 input row per cycle, via multiple input channels. The small table and the big table shares the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. Similar to hashJoinV3 , small table and big table should be fed only once.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, log2(small table max num of rows).
CH_NM	number of input channels, 1,2,4.
BF_HASH_NM	number of bloom filter, 1,2,3.
BF_W	bloom-filter hash width.
EN_BF	bloom-filter switch, 0 for off, 1 for on.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	contains build id, fixed hash depth
pu_end_status_strms	returns next build id, fixed hash depth, joined number
j_strm	output of joined result
j_e_strm	end flag of joined result

hashBuildProbeV4

#include "xf_database/hash_join_v4.hpp"

template <
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int HASHO,
    int ARW,
    int CH_NM,
    int BF_HASH_NM,
    int BFW,
    int EN_BF
    >
static void hashBuildProbeV4 (
    bool& build_probe_flag,
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Hash-Build-Probe v4 primitive. Compared with HashBuildProbeV3 , it enables bloom filter to reduce redundant access to HBM which can further reduce run-time of hash join. Build and probe are separately performed and controlled by a boolean flag. Mutiple build and probe are also provided, and it should make sure all rows in build phase can be stored temporarily in HBM to maintain correctness.

The maximum size of small table is 256MBx8=2GB in this design. The total hash entries is equal to 1<<(HASHWH + HASHWL), and it is limitied to maximun of 1M entries because of the size of URAM in a single SLR.

Parameters:

KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
HASHO	number of hash bits used for overflow hash counter, 8-12.
ARW	width of address, log2(small table max num of rows).
CH_NM	number of input channels, 1,2,4.
BF_HASH_NM	number of hash functions in bloom filter, 1,2,3.
BFW	bloom-filter hash width.
EN_BF	bloom-filter switch, 0 for off, 1 for on.
build_probe_flag	0:build 1:probe
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	contains build ID, probe ID, fixed hash depth, joined number of last probe and start addr of unused stb_buf for each PU
pu_end_status_strms	returns next build ID, next probe ID, fixed hash depth, joined number of current probe and end addr of stb_buf for each PU
j_strm	output of joined rows.
j_e_strm	is the end flag of joined result.

hashLookup3

hashLookup3 overload (1)

#include "xf_database/hash_lookup3.hpp"

template <int W>
void hashLookup3 (
    hls::stream <ap_uint <W>>& key_strm,
    hls::stream <ap_uint <64>>& hash_strm
    )

lookup3 algorithm, 64-bit hash. II=1 when W<=96, otherwise II=(W/96).

Parameters:

W	the bit width of ap_uint type for input message stream.
key_strm	the message being hashed.
hash_strm	the result.

hashLookup3 overload (2)

#include "xf_database/hash_lookup3.hpp"

template <int W>
void hashLookup3 (
    hls::stream <ap_uint <W>>& key_strm,
    hls::stream <ap_uint <32>>& hash_strm
    )

lookup3 algorithm, 32-bit hash. II=1 when W<=96, otherwise II=(W/96).

Parameters:

W	the bit width of ap_uint type for input message stream.
key_strm	the message being hashed.
hash_strm	the result.

hashLookup3 overload (3)

#include "xf_database/hash_lookup3.hpp"

template <
    int WK,
    int WH
    >
void hashLookup3 (
    hls::stream <ap_uint <WK>>& key_strm,
    hls::stream <bool>& e_key_strm,
    hls::stream <ap_uint <WH>>& hash_strm,
    hls::stream <bool>& e_hash_strm
    )

lookup3 algorithm, 64-bit or 32-bit hash.

Parameters:

WK	the bit width of input message stream.
WH	the bit width of output hash stream, must be 64 or 32.
key_strm	the message being hashed.
e_key_strm	end of key flag stream.
hash_strm	the result.
e_hash_strm	end of hash flag stream.

hashMultiJoin

#include "xf_database/hash_multi_join.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int S_PW,
    int B_PW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM
    >
void hashMultiJoin (
    hls::stream <ap_uint <3>>& join_flag_strm,
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    ap_uint <64>* htb0_buf,
    ap_uint <64>* htb1_buf,
    ap_uint <64>* htb2_buf,
    ap_uint <64>* htb3_buf,
    ap_uint <64>* htb4_buf,
    ap_uint <64>* htb5_buf,
    ap_uint <64>* htb6_buf,
    ap_uint <64>* htb7_buf,
    ap_uint <64>* stb0_buf,
    ap_uint <64>* stb1_buf,
    ap_uint <64>* stb2_buf,
    ap_uint <64>* stb3_buf,
    ap_uint <64>* stb4_buf,
    ap_uint <64>* stb5_buf,
    ap_uint <64>* stb6_buf,
    ap_uint <64>* stb7_buf,
    hls::stream <ap_uint <32>>& pu_begin_status_strms,
    hls::stream <ap_uint <32>>& pu_end_status_strms,
    hls::stream <ap_uint <KEYW+S_PW+B_PW>>& j_strm,
    hls::stream <bool>& j_e_strm
    )

Multi-PU Hash-Multi-Join primitive, using multiple DDR/HBM buffers.

This primitive shares most of the structure of hashJoinV3 . The inner table should be fed once, followed by the outer table once.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
S_PW	width of payload of small table.
B_PW	width of payload of big table.
HASHWH	number of hash bits used for PU/buffer selection, 1~3.
HASHWL	number of hash bits used for hash-table in PU.
ARW	width of address, larger than 24 is suggested.
CH_NM	number of input channels, 1,2,4.
join_flag_strm	specifies the join type, this flag is only read once.
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
htb0_buf	HBM/DDR buffer of hash_table0
htb1_buf	HBM/DDR buffer of hash_table1
htb2_buf	HBM/DDR buffer of hash_table2
htb3_buf	HBM/DDR buffer of hash_table3
htb4_buf	HBM/DDR buffer of hash_table4
htb5_buf	HBM/DDR buffer of hash_table5
htb6_buf	HBM/DDR buffer of hash_table6
htb7_buf	HBM/DDR buffer of hash_table7
stb0_buf	HBM/DDR buffer of PU0
stb1_buf	HBM/DDR buffer of PU1
stb2_buf	HBM/DDR buffer of PU2
stb3_buf	HBM/DDR buffer of PU3
stb4_buf	HBM/DDR buffer of PU4
stb5_buf	HBM/DDR buffer of PU5
stb6_buf	HBM/DDR buffer of PU6
stb7_buf	HBM/DDR buffer of PU7
pu_begin_status_strms	constains depth of hash, row number of join result
pu_end_status_strms	constains depth of hash, row number of join result
j_strm	output of joined result
j_e_strm	end flag of joined result

hashMurmur3

#include "xf_database/hash_murmur3.hpp"

template <
    int W,
    int H
    >
void hashMurmur3 (
    hls::stream <ap_uint <W>>& key_strm,
    hls::stream <ap_uint <H>>& hash_strm
    )

murmur3 algorithm.

Parameters:

W	the bit width of ap_uint type for input message stream.
h	the bit width of ap_uint type for output hash stream.
key_strm	the message being hashed.
hash_strm	the result.

hashPartition

#include "xf_database/hash_partition.hpp"

template <
    int HASH_MODE,
    int KEYW,
    int PW,
    int EW,
    int HASHWH,
    int HASHWL,
    int ARW,
    int CH_NM,
    int COL_NM
    >
void hashPartition (
    bool mk_on,
    int depth,
    hls::stream <int>& bit_num_strm,
    hls::stream <ap_uint <KEYW>> k0_strm_arry [CH_NM],
    hls::stream <ap_uint <PW>> p0_strm_arry [CH_NM],
    hls::stream <bool> e0_strm_arry [CH_NM],
    hls::stream <ap_uint <16>>& o_bkpu_num_strm,
    hls::stream <ap_uint <10>>& o_nm_strm,
    hls::stream <ap_uint <EW>> o_kpld_strm [COL_NM]
    )

Hash-Partition primitive.

Parameters:

HASH_MODE	0 for radix and 1 for Jenkin’s Lookup3 hash.
KEYW	width of key, in bit.
PW	width of max payload, in bit.
EW	element data width of input table, in bit.
HASHWH	number of hash bits used for PU selection.
HASHWL	number of hash bits used for partition selection.
ARW	width of address for URAM
CH_NM	number of input channels, 1,2,4.
COL_NM	number of input columns, 1~8.
mk_on	input of double key flag, 0 for off, 1 for on.
depth	input of depth of each hash bucket in URAM.
bit_num_strm	input of partition number, log2(number of partition).
k0_strm_arry	input of key columns of both tables.
p0_strm_arry	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
o_bkpu_num_strm	output of index for bucket and PU
o_nm_strm	output of row number each time
o_kpld_strm	output of key+payload

hashSemiJoin

#include "xf_database/hash_semi_join.hpp"

template <
    int HashMode,
    int WKey,
    int WPayload,
    int WHashHigh,
    int WhashLow,
    int WTmpBufferAddress,
    int WTmpBuffer,
    int NChannels,
    int WBloomFilter,
    int EnBloomFilter
    >
static void hashSemiJoin (
    hls::stream <ap_uint <WKey>> key_istrms [NChannels],
    hls::stream <ap_uint <WPayload>> payload_istrms [NChannels],
    hls::stream <bool> e0_strm_arry [NChannels],
    ap_uint <WTmpBuffer>* pu0_tmp_rwtpr,
    ap_uint <WTmpBuffer>* pu1_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu2_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu3_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu4_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu5_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu6_tmp_rwptr,
    ap_uint <WTmpBuffer>* pu7_tmp_rwptr,
    hls::stream <ap_uint <WPayload>>& join_ostrm,
    hls::stream <bool>& end_ostrm
    )

Multi-PU Hash-Semi-Join primitive, using multiple DDR/HBM buffers.

The max number of lines of inner table is 2M in this design. It is assumed that the hash-conflict is within 256K per bin.

This module can accept more than 1 input row per cycle, via multiple input channels. The outer table and the inner table share the same input ports, so the width of the payload should be the max of both, while the data should be aligned to the little-end. The inner table should be fed TWICE, followed by the outer table ONCE.

Parameters:

HashMode	0 for radix and 1 for Jenkin’s Lookup3 hash.
WKey	width of key, in bit.
WPayload	width of payload of outer table.
WHashHigh	number of hash bits used for PU/buffer selection, 1~3.
WhashLow	number of hash bits used for hash-table in PU.
WTmpBufferAddress	width of address, log2(inner table max num of rows).
WTmpBuffer	width of buffer.
NChannels	number of input channels, 1,2,4.
WBloomFilter	bloom-filter hash width.
EnBloomFilter	bloom-filter switch, 0 for off, 1 for on.
key_istrms	input of key columns of both tables.
payload_istrms	input of payload columns of both tables.
e0_strm_arry	input of end signal of both tables.
pu0_tmp_rwtpr	HBM/DDR buffer of PU0
pu1_tmp_rwptr	HBM/DDR buffer of PU1
pu2_tmp_rwptr	HBM/DDR buffer of PU2
pu3_tmp_rwptr	HBM/DDR buffer of PU3
pu4_tmp_rwptr	HBM/DDR buffer of PU4
pu5_tmp_rwptr	HBM/DDR buffer of PU5
pu6_tmp_rwptr	HBM/DDR buffer of PU6
pu7_tmp_rwptr	HBM/DDR buffer of PU7
join_ostrm	output of joined rows.
end_ostrm	end signal of joined rows.

insertSort

insertSort overload (1)

#include "xf_database/insert_sort.hpp"

template <
    typename KEY_TYPE,
    int MAX_SORT_NUMBER
    >
void insertSort (
    hls::stream <KEY_TYPE>& kinStrm,
    hls::stream <bool>& endInStrm,
    hls::stream <KEY_TYPE>& koutStrm,
    hls::stream <bool>& endOutStrm,
    bool order
    )

Insert sort top function.

Parameters:

KEY_TYPE	the input and output key type
MAX_SORT_NUMBER	the max number of the sequence can be sorted
kinStrm	input key stream
endInStrm	end flag stream for input
koutStrm	output key stream
endOutStrm	end flag stream for output
order	1:sort ascending 0:sort descending

insertSort overload (2)

#include "xf_database/insert_sort.hpp"

template <
    typename KEY_TYPE,
    typename DATA_TYPE,
    int MAX_SORT_NUMBER
    >
void insertSort (
    hls::stream <DATA_TYPE>& dinStrm,
    hls::stream <KEY_TYPE>& kinStrm,
    hls::stream <bool>& endInStrm,
    hls::stream <DATA_TYPE>& doutStrm,
    hls::stream <KEY_TYPE>& koutStrm,
    hls::stream <bool>& endOutStrm,
    bool order
    )

Insert sort top function.

Parameters:

KEY_TYPE	the input and output key type
DATA_TYPE	the input and output data type
MAX_SORT_NUMBER	the max number of the sequence can be sorted
dinStrm	input data stream
kinStrm	input key stream
endInStrm	end flag stream for input
doutStrm	output data stream
koutStrm	output key stream
endOutStrm	end flag stream for output
order	1:sort ascending 0:sort descending

mergeJoin

#include "xf_database/merge_join.hpp"

template <
    typename KEY_T,
    typename LEFT_FIELD_T,
    typename RIGHT_FIELD_T
    >
void mergeJoin (
    bool isascend,
    hls::stream <KEY_T>& left_strm_in_key,
    hls::stream <LEFT_FIELD_T>& left_strm_in_field,
    hls::stream <bool>& left_e_strm,
    hls::stream <KEY_T>& right_strm_in_key,
    hls::stream <RIGHT_FIELD_T>& right_strm_in_field,
    hls::stream <bool>& right_e_strm,
    hls::stream <KEY_T>& left_strm_out_key,
    hls::stream <LEFT_FIELD_T>& left_strm_out_field,
    hls::stream <KEY_T>& right_strm_out_key,
    hls::stream <RIGHT_FIELD_T>& right_strm_out_field,
    hls::stream <bool>& out_e_strm
    )

merge join function for sorted tables without duplicated key in the left table

Parameters:

KEY_T	the type of the key of left table
LEFT_FIELD_T	the type of the field of left table
RIGHT_FIELD_T	the type of the field of right table
isascend	the flag to show if the input tables are ascend or descend tables
left_strm_in_key	the key stream of the left input table
left_strm_in_field	the field stream of the left input table
left_e_strm	the end flag stream to mark the end of left input table
right_strm_in_key	the key stream of the right input table
right_strm_in_field	the field stream of the right input table
right_e_strm	the end flag stream to mark the end of right input table
left_strm_out_key	the output key stream of left table
left_strm_out_field	the output field stream of left table
right_strm_out_key	the output key stream of right table
right_strm_out_field	the output field stream of right
out_e_strm	the end flag stream to mark the end of out table

mergeLeftJoin

#include "xf_database/merge_left_join.hpp"

template <
    typename KEY_T,
    typename LEFT_FIELD_T,
    typename RIGHT_FIELD_T
    >
void mergeLeftJoin (
    bool isascend,
    hls::stream <KEY_T>& left_strm_in_key,
    hls::stream <LEFT_FIELD_T>& left_strm_in_field,
    hls::stream <bool>& left_e_strm,
    hls::stream <KEY_T>& right_strm_in_key,
    hls::stream <RIGHT_FIELD_T>& right_strm_in_field,
    hls::stream <bool>& right_e_strm,
    hls::stream <KEY_T>& left_strm_out_key,
    hls::stream <LEFT_FIELD_T>& left_strm_out_field,
    hls::stream <KEY_T>& right_strm_out_key,
    hls::stream <RIGHT_FIELD_T>& right_strm_out_field,
    hls::stream <bool>& out_e_strm,
    hls::stream <bool>& isnull_strm
    )

merge left join function for sorted table, left table should not have duplicated keys.

Parameters:

KEY_T	the type of the key
LEFT_FIELD_T	the type of the field of left table
RIGHT_FIELD_T	the type of the field of right table
isascend	flag to show if the input tables are ascend tables
left_strm_in_key	the key stream of the left input table
left_strm_in_field	the field stream of the left input table
left_e_strm	the end flag stream to mark the end of left input table
right_strm_in_key	the key stream of the right input table
right_strm_in_field	the field stream of the right input table
right_e_strm	the end flag stream to mark the end of right input table
left_strm_out_key	the output key stream of left table
left_strm_out_field	the output field stream of left table
right_strm_out_key	the output key stream of right table
right_strm_out_field	the output field stream of right
out_e_strm	the end flag stream to mark the end of out table
isnull_strm	the isnull stream to show if the result right table is null.

mergeSort

mergeSort overload (1)

#include "xf_database/merge_sort.hpp"

template <typename Key_Type>
void mergeSort (
    hls::stream <Key_Type>& left_kin_strm,
    hls::stream <bool>& left_strm_in_end,
    hls::stream <Key_Type>& right_kin_strm,
    hls::stream <bool>& right_strm_in_end,
    hls::stream <Key_Type>& kout_strm,
    hls::stream <bool>& strm_out_end,
    bool order
    )

Merge sort function.

Parameters:

Data_Type	the input and output key type
left_kin_strm	input key stream
left_strm_in_end	end flag stream for left input
right_kin_strm	input key stream
right_strm_in_end	end flag stream for right input
kout_strm	output key stream
strm_out_end	end flag stream for output data
order	1:ascending 0:descending

mergeSort overload (2)

#include "xf_database/merge_sort.hpp"

template <
    typename Data_Type,
    typename Key_Type
    >
void mergeSort (
    hls::stream <Data_Type>& left_din_strm,
    hls::stream <Key_Type>& left_kin_strm,
    hls::stream <bool>& left_strm_in_end,
    hls::stream <Data_Type>& right_din_strm,
    hls::stream <Key_Type>& right_kin_strm,
    hls::stream <bool>& right_strm_in_end,
    hls::stream <Data_Type>& dout_strm,
    hls::stream <Key_Type>& kout_strm,
    hls::stream <bool>& strm_out_end,
    bool order
    )

Merge sort function.

Parameters:

Data_Type	the input and output data type
Data_Type	the input and output key type
left_din_strm	input left data stream
left_kin_strm	input key stream
left_strm_in_end	end flag stream for left input
right_din_strm	input right data stream
right_kin_strm	input key stream
right_strm_in_end	end flag stream for right input
dout_strm	output data stream
kout_strm	output key stream
strm_out_end	end flag stream for output data
order	1:ascending 0:descending

nestedLoopJoin

#include "xf_database/nested_loop_join.hpp"

template <
    int CMP_NUM,
    typename KEY_T,
    typename LEFT_FIELD_T,
    typename RIGHT_FIELD_T
    >
void nestedLoopJoin (
    hls::stream <KEY_T>& strm_in_left_key,
    hls::stream <LEFT_FIELD_T>& strm_in_left_field,
    hls::stream <bool>& strm_in_left_e,
    hls::stream <KEY_T>& strm_in_right_key,
    hls::stream <RIGHT_FIELD_T>& strm_in_right_field,
    hls::stream <bool>& strm_in_right_e,
    hls::stream <KEY_T> strm_out_left_key [CMP_NUM],
    hls::stream <LEFT_FIELD_T> strm_out_left_field [CMP_NUM],
    hls::stream <KEY_T> strm_out_right_key [CMP_NUM],
    hls::stream <RIGHT_FIELD_T> strm_out_right_field [CMP_NUM],
    hls::stream <bool> strm_out_e [CMP_NUM]
    )

Nested loop join function.

Parameters:

KEY_T	the type of the key of left table
LEFT_FIELD_T	the type of the field of left table
RIGHT_FIELD_T	the type of the field of right table
strm_in_left_key	the key stream of the left input table
strm_in_left_field	the field stream of the left input table
strm_in_left_e	the end flag stream to mark the end of left input table
strm_in_right_key	the key stream of the right input table
strm_in_right_field	the field stream of the right input table
strm_in_right_e	the end flag stream to mark the end of right input table
strm_out_left_key	the output key stream of left table
strm_out_left_field	the output field stream of left table
strm_out_right_key	the output key stream of right table
strm_out_right_field	the output field stream of right
strm_out_e	the end flag stream to mark the end of out table

scanCmpStrCol

#include "xf_database/scan_cmp_str_col.hpp"

void scanCmpStrCol (
    ap_uint <512>* ddr_ptr,
    hls::stream <int>& size,
    hls::stream <int>& num_str,
    hls::stream <ap_uint <512>>& cnst_stream,
    hls::stream <bool>& out_stream,
    hls::stream <bool>& e_str_o
    )

sacn multiple columns of string in global memory, and compare each of them with constant string

Parameters:

ddr_ptr	input string array stored in global memory.
size	the number of times reading global memory
num_str	the number of actual strings
cnst_stream	input constant string stream, 512 bits in heading-length and padding-zero format, read only once as configuration.
out_stream	output whether each string is equal to the constant string, true indicates they are equal.
e_str_o	end flag stream for output stream.

scanCol

scanCol overload (1)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 1 column from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
c0vec_ptr	buffer pointer to column 0.
nrow	number of row to scan.
c0_strm	column 0 stream.
e_row_strm	output end flag stream.

scanCol overload (2)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0,
    int size1
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <ap_uint <8*size1>>& c1_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 2 columns from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
nrow	number of row to scan.
c0_strm	column 0 stream.
c1_strm	column 1 stream.
e_row_strm	output end flag stream.

scanCol overload (3)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0,
    int size1,
    int size2
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <ap_uint <8*size1>>& c1_strm,
    hls::stream <ap_uint <8*size2>>& c2_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 3 columns from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
nrow	number of row to scan.
c0_strm	column 0 stream.
c1_strm	column 1 stream.
c2_strm	column 2 stream.
e_row_strm	output end flag stream.

scanCol overload (4)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0,
    int size1,
    int size2,
    int size3
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    ap_uint <8*size3*vec_len>* c3vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <ap_uint <8*size1>>& c1_strm,
    hls::stream <ap_uint <8*size2>>& c2_strm,
    hls::stream <ap_uint <8*size3>>& c3_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 4 columns from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
size3	size of column 3, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c3vec_ptr	buffer pointer to column 3.
nrow	number of row to scan.
c0_strm	column 0 stream.
c1_strm	column 1 stream.
c2_strm	column 2 stream.
c3_strm	column 3 stream.
e_row_strm	output end flag stream.

scanCol overload (5)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0,
    int size1,
    int size2,
    int size3,
    int size4
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    ap_uint <8*size3*vec_len>* c3vec_ptr,
    ap_uint <8*size4*vec_len>* c4vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <ap_uint <8*size1>>& c1_strm,
    hls::stream <ap_uint <8*size2>>& c2_strm,
    hls::stream <ap_uint <8*size3>>& c3_strm,
    hls::stream <ap_uint <8*size4>>& c4_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 5 columns from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
size3	size of column 3, in byte.
size4	size of column 4, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c3vec_ptr	buffer pointer to column 3.
c4vec_ptr	buffer pointer to column 4.
nrow	number of row to scan.
c0_strm	column 0 stream.
c1_strm	column 1 stream.
c2_strm	column 2 stream.
c3_strm	column 3 stream.
c4_strm	column 4 stream.
e_row_strm	output end flag stream.

scanCol overload (6)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int size0,
    int size1,
    int size2,
    int size3,
    int size4,
    int size5
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    ap_uint <8*size3*vec_len>* c3vec_ptr,
    ap_uint <8*size4*vec_len>* c4vec_ptr,
    ap_uint <8*size5*vec_len>* c5vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>>& c0_strm,
    hls::stream <ap_uint <8*size1>>& c1_strm,
    hls::stream <ap_uint <8*size2>>& c2_strm,
    hls::stream <ap_uint <8*size3>>& c3_strm,
    hls::stream <ap_uint <8*size4>>& c4_strm,
    hls::stream <ap_uint <8*size5>>& c5_strm,
    hls::stream <bool>& e_row_strm
    )

Scan 6 columns from DDR/HBM buffers.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
size3	size of column 3, in byte.
size4	size of column 4, in byte.
size5	size of column 5, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c3vec_ptr	buffer pointer to column 3.
c4vec_ptr	buffer pointer to column 4.
c5vec_ptr	buffer pointer to column 5.
nrow	number of row to scan.
c0_strm	column 0 stream.
c1_strm	column 1 stream.
c2_strm	column 2 stream.
c3_strm	column 3 stream.
c4_strm	column 4 stream.
c5_strm	column 5 stream.
e_row_strm	output end flag stream.

scanCol overload (7)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_num,
    int size0
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_num],
    hls::stream <bool> e_row_strm [ch_num]
    )

Scan one column from DDR/HBM buffers, emit multiple rows concurrently.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
ch_num	number of concurrent output channels per column.
size0	size of column 0, in byte.
c0vec_ptr	buffer pointer to column 0.
nrow	number of row to scan.
c0_strm	array of column 0 stream.
e_row_strm	array of output end flag stream.

scanCol overload (8)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_num,
    int size0,
    int size1
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_num],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_num],
    hls::stream <bool> e_row_strm [ch_num]
    )

Scan two columns from DDR/HBM buffers, emit multiple rows concurrently.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
ch_num	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
nrow	number of row to scan.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
e_row_strm	array of output end flag stream.

scanCol overload (9)

#include "xf_database/scan_col.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_num,
    int size0,
    int size1,
    int size2
    >
void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    const int nrow,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_num],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_num],
    hls::stream <ap_uint <8*size2>> c2_strm [ch_num],
    hls::stream <bool> e_row_strm [ch_num]
    )

Scan three columns from DDR/HBM buffers, emit multiple rows concurrently.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	number of items to be scanned as a vector from AXI port.
ch_num	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
nrow	number of row to scan.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
c2_strm	array of column 2 stream.
e_row_strm	array of output end flag stream.

scanCol overload (10)

#include "xf_database/scan_col_2.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_nm,
    int size0,
    int size1
    >
static void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_nm],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_nm],
    hls::stream <bool> e_row_strm [ch_nm]
    )

scan 2 columns from DDR/HBM buffers.

The LSB of first vector of first column specifies the number of rows to be scanned. For a following buffer, if the first vector is zero, same number of zeros will be emitted, otherwise, same number of rows will be read from the buffer.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	scan this number of items as a vector from AXI port.
ch_nm	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
e_row_strm	array of output end flag stream.

scanCol overload (11)

#include "xf_database/scan_col_2.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_nm,
    int size0,
    int size1,
    int size2
    >
static void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_nm],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_nm],
    hls::stream <ap_uint <8*size2>> c2_strm [ch_nm],
    hls::stream <bool> e_row_strm [ch_nm]
    )

scan 3 columns from DDR/HBM buffers.

The LSB of first vector of first column specifies the number of rows to be scanned. For a following buffer, if the first vector is zero, same number of zeros will be emitted, otherwise, same number of rows will be read from the buffer.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	scan this number of items as a vector from AXI port.
ch_nm	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
c2_strm	array of column 2 stream.
e_row_strm	array of output end flag stream.

scanCol overload (12)

#include "xf_database/scan_col_2.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_nm,
    int size0,
    int size1,
    int size2,
    int size3
    >
static void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    ap_uint <8*size3*vec_len>* c3vec_ptr,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_nm],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_nm],
    hls::stream <ap_uint <8*size2>> c2_strm [ch_nm],
    hls::stream <ap_uint <8*size3>> c3_strm [ch_nm],
    hls::stream <bool> e_row_strm [ch_nm]
    )

scan 4 columns from DDR/HBM buffers.

The LSB of first vector of first column specifies the number of rows to be scanned. For a following buffer, if the first vector is zero, same number of zeros will be emitted, otherwise, same number of rows will be read from the buffer.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	scan this number of items as a vector from AXI port.
ch_nm	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
size3	size of column 3, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c3vec_ptr	buffer pointer to column 3.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
c2_strm	array of column 2 stream.
c3_strm	array of column 3 stream.
e_row_strm	array of output end flag stream.

scanCol overload (13)

#include "xf_database/scan_col_2.hpp"

template <
    int burst_len,
    int vec_len,
    int ch_nm,
    int size0,
    int size1,
    int size2,
    int size3,
    int size4
    >
static void scanCol (
    ap_uint <8*size0*vec_len>* c0vec_ptr,
    ap_uint <8*size1*vec_len>* c1vec_ptr,
    ap_uint <8*size2*vec_len>* c2vec_ptr,
    ap_uint <8*size3*vec_len>* c3vec_ptr,
    ap_uint <8*size4*vec_len>* c4vec_ptr,
    hls::stream <ap_uint <8*size0>> c0_strm [ch_nm],
    hls::stream <ap_uint <8*size1>> c1_strm [ch_nm],
    hls::stream <ap_uint <8*size2>> c2_strm [ch_nm],
    hls::stream <ap_uint <8*size3>> c3_strm [ch_nm],
    hls::stream <ap_uint <8*size4>> c4_strm [ch_nm],
    hls::stream <bool> e_row_strm [ch_nm]
    )

scan 5 columns from DDR/HBM buffers.

The LSB of first vector of first column specifies the number of rows to be scanned. For a following buffer, if the first vector is zero, same number of zeros will be emitted, otherwise, same number of rows will be read from the buffer.

Parameters:

burst_len	burst read length, must be supported by MC.
vec_len	scan this number of items as a vector from AXI port.
ch_nm	number of concurrent output channels per column.
size0	size of column 0, in byte.
size1	size of column 1, in byte.
size2	size of column 2, in byte.
size3	size of column 3, in byte.
size4	size of column 4, in byte.
c0vec_ptr	buffer pointer to column 0.
c1vec_ptr	buffer pointer to column 1.
c2vec_ptr	buffer pointer to column 2.
c3vec_ptr	buffer pointer to column 3.
c4vec_ptr	buffer pointer to column 4.
c0_strm	array of column 0 stream.
c1_strm	array of column 1 stream.
c2_strm	array of column 2 stream.
c3_strm	array of column 3 stream.
c4_strm	array of column 4 stream.
e_row_strm	array of output end flag stream.

staticEval

staticEval overload (1)

#include "xf_database/static_eval.hpp"

template <
    typename T,
    typename T_O,
    T_O(*)(T) opf
    >
void staticEval (
    hls::stream <T>& in_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <T_O>& out_strm,
    hls::stream <bool>& e_out_strm
    )

One stream input static evaluation.

static_eval function calculates the experssion result that user defined. This result will be passed to aggregate module as the input. When calling this API, the T T_O are the input/output data types for each parameter of user code. E.g.

// decl
long user_func(int a);
// use
 database::static_eval<int, long, user_func>(
  in1_strm, e_in_strm, out_strm, e_out_strm);

In the above call, int is the data type of input of user_func , and long is the return type of user_func .

Parameters:

T	the input stream type, inferred from argument
T_O	the output stream type, inferred from argument
opf	the user-defined expression function
in_strm	input data stream
e_in_strm	end flag stream for input data
out_strm	output data stream
e_out_strm	end flag stream for output data

staticEval overload (2)

#include "xf_database/static_eval.hpp"

template <
    typename T1,
    typename T2,
    typename T_O,
    T_O(*)(T1, T2) opf
    >
void staticEval (
    hls::stream <T1>& in1_strm,
    hls::stream <T2>& in2_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <T_O>& out_strm,
    hls::stream <bool>& e_out_strm
    )

Two stream input static evaluation.

static_eval function calculate the experssion result that user defined. This result will be passed to aggregate module as the input. When calling this API, the T1 T2 T_O are the input/output data types for each parameter of user code. E.g.

// decl
long user_func(int a, int b);
// use
 database::static_eval<int, int, long, user_func>(
  in1_strm, in2_strm, e_in_strm, out_strm, e_out_strm);

In the above call, two int are the data type of input of user_func , and long is the return type of user_func .

Parameters:

T1	the input stream type, inferred from argument
T2	the input stream type, inferred from argument
T_O	the output stream type, inferred from argument
opf	the user-defined expression function
in1_strm	input data stream
in2_strm	input data stream
e_in_strm	end flag stream for input data
out_strm	output data stream
e_out_strm	end flag stream for output data

staticEval overload (3)

#include "xf_database/static_eval.hpp"

template <
    typename T1,
    typename T2,
    typename T3,
    typename T_O,
    T_O(*)(T1, T2, T3) opf
    >
void staticEval (
    hls::stream <T1>& in1_strm,
    hls::stream <T2>& in2_strm,
    hls::stream <T3>& in3_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <T_O>& out_strm,
    hls::stream <bool>& e_out_strm
    )

Three stream input static evaluation.

static_eval function calculate the experssion result that user defined. This result will be passed to aggregate module as the input. When calling this API, the T1 T2 T3 T_O are the input/output data types for each parameter of user code. E.g.

// decl
long user_func(int a, int b, int c);
// use
 database::static_eval<int, int, int, long, user_func>(
  in1_strm, in2_strm, in3_strm, e_in_strm,
  out_strm, e_out_strm);

In the above call, three int are the data type of input of user_func , and long is the return type of user_func .

Parameters:

T1	the input stream type, inferred from argument
T2	the input stream type, inferred from argument
T3	the input stream type, inferred from argument
T_O	the output stream type, inferred from argument
opf	the user-defined expression function
in1_strm	input data stream
in2_strm	input data stream
in3_strm	input data stream
e_in_strm	end flag stream for input data
out_strm	output data stream
e_out_strm	end flag stream for output data

staticEval overload (4)

#include "xf_database/static_eval.hpp"

template <
    typename T1,
    typename T2,
    typename T3,
    typename T4,
    typename T_O,
    T_O(*)(T1, T2, T3, T4) opf
    >
void staticEval (
    hls::stream <T1>& in1_strm,
    hls::stream <T2>& in2_strm,
    hls::stream <T3>& in3_strm,
    hls::stream <T4>& in4_strm,
    hls::stream <bool>& e_in_strm,
    hls::stream <T_O>& out_strm,
    hls::stream <bool>& e_out_strm
    )

Four stream input static evaluation.

static_eval function calculate the experssion result that user defined. This result will be passed to aggregate module as the input. When calling this API, the T1 T2 T3 T_O are the input/output data types for each parameter of user code. E.g.

// decl
long user_func(int a, int b, int c, int d);
// use
 database::static_eval<int, int, int, int, long, user_func>(
  in1_strm, in2_strm, in3_strm, in3_strm, e_in_strm,
  out_strm, e_out_strm);

In the above call, four int are the data type of input of user_func , and long is the return type of user_func .

Parameters:

T1	the input stream type, inferred from argument
T2	the input stream type, inferred from argument
T3	the input stream type, inferred from argument
T4	the input stream type, inferred from argument
T_O	the output stream type, inferred from argument
opf	the user-defined expression function
in1_strm	input data stream
in2_strm	input data stream
in3_strm	input data stream
in4_strm	input data stream
e_in_strm	end flag stream for input data
out_strm	output data stream
e_out_strm	end flag stream for output data