[tests]: added test case for MaxPool with ceil mode

tests/fpgadataflow/test_layer_streaming_maxpool_batch.py

@@ -35,19 +35,22 @@ import finn.core.onnx_exec as oxe
 from finn.analysis.fpgadataflow.exp_cycles_per_layer import exp_cycles_per_layer
 from finn.core.datatype import DataType
 from finn.core.modelwrapper import ModelWrapper
+from finn.custom_op.general.maxpoolnhwc import compute_pool_output_dim
 
 # from finn.custom_op.registry import getCustomOp
 from finn.transformation.fpgadataflow.compile_cppsim import CompileCppSim
+from finn.transformation.fpgadataflow.convert_to_hls_layers import InferStreamingMaxPool
 from finn.transformation.fpgadataflow.hlssynth_ip import HLSSynthIP
 from finn.transformation.fpgadataflow.prepare_cppsim import PrepareCppSim
 from finn.transformation.fpgadataflow.prepare_ip import PrepareIP
 from finn.transformation.fpgadataflow.prepare_rtlsim import PrepareRTLSim
 from finn.transformation.fpgadataflow.set_exec_mode import SetExecMode
 from finn.transformation.general import GiveUniqueNodeNames
+from finn.transformation.infer_shapes import InferShapes
 from finn.util.basic import gen_finn_dt_tensor
 
 
-def make_single_maxpoolnhwc_modelwrapper(k, ifm_ch, ifm_dim, ofm_dim, idt):
+def make_single_maxpoolnhwc_modelwrapper(k, ifm_ch, ifm_dim, ofm_dim, idt, ceil_mode):
     k_h, k_w = k
     ifm_dim_h, ifm_dim_w = ifm_dim
     ofm_dim_h, ofm_dim_w = ofm_dim
@@ -66,6 +69,7 @@ def make_single_maxpoolnhwc_modelwrapper(k, ifm_ch, ifm_dim, ofm_dim, idt):
         domain="finn.custom_op.general",
         kernel_shape=[k_h, k_w],
         strides=[k_h, k_w],
+        ceil_mode=ceil_mode,
         pads=[0, 0, 0, 0],
     )
     graph = helper.make_graph(
@@ -81,7 +85,9 @@ def make_single_maxpoolnhwc_modelwrapper(k, ifm_ch, ifm_dim, ofm_dim, idt):
     return model
 
 
-def make_single_streamingmaxpool_modelwrapper(k, ifm_ch, pe, ifm_dim, ofm_dim, idt):
+def make_single_streamingmaxpool_modelwrapper(
+    k, ifm_ch, pe, ifm_dim, ofm_dim, idt, ceil_mode
+):
     k_h, k_w = k
     ifm_dim_h, ifm_dim_w = ifm_dim
     ofm_dim_h, ofm_dim_w = ofm_dim
@@ -103,6 +109,7 @@ def make_single_streamingmaxpool_modelwrapper(k, ifm_ch, pe, ifm_dim, ofm_dim, i
         NumChannels=ifm_ch,
         PE=pe,
         ImgDim=[ifm_dim_h, ifm_dim_w],
+        CeilMode=ceil_mode,
         dataType=idt.name,
     )
     graph = helper.make_graph(
@@ -129,16 +136,20 @@ def prepare_inputs(input_tensor):
 # kernel size
 @pytest.mark.parametrize("k", [2, 4])
 # input dimension
-@pytest.mark.parametrize("ifm_dim", [4, 8])
+@pytest.mark.parametrize("ifm_dim", [4, 10])
 # input channels
 @pytest.mark.parametrize("ifm_ch", [1, 3])  # 1,3
 # pe
 @pytest.mark.parametrize("pe", [1, 3])
+# ceil mode
+@pytest.mark.parametrize("ceil_mode", [1])
 # execution mode
 @pytest.mark.parametrize("exec_mode", ["rtlsim", "cppsim"])
 @pytest.mark.slow
 @pytest.mark.vivado
-def test_fpgadataflow_streamingmaxpool(idt, dim_1d, k, ifm_dim, ifm_ch, pe, exec_mode):
+def test_fpgadataflow_streamingmaxpool(
+    idt, dim_1d, k, ifm_dim, ifm_ch, pe, ceil_mode, exec_mode
+):
     ifm_dim_h = ifm_dim
     k_h = k
     if dim_1d:
@@ -152,12 +163,12 @@ def test_fpgadataflow_streamingmaxpool(idt, dim_1d, k, ifm_dim, ifm_ch, pe, exec
 
     stride_h = k_h
     stride_w = k_w
-    ofm_dim_h = int(((ifm_dim_h - k_h) / stride_h) + 1)
-    ofm_dim_w = int(((ifm_dim_w - k_w) / stride_w) + 1)
+    ofm_dim_h = compute_pool_output_dim(ifm_dim_h, k_h, stride_h, 0, ceil_mode)
+    ofm_dim_w = compute_pool_output_dim(ifm_dim_w, k_w, stride_w, 0, ceil_mode)
     ofm_dim = (ofm_dim_h, ofm_dim_w)
     if idt == DataType["BIPOLAR"] and dim_1d:
         pytest.skip("Skipping binary StreamingMaxPool_1d (not implemented)")
-    if ifm_dim_h % k_h != 0 or ifm_dim_w % k_w != 0:
+    if (ifm_dim_h % k_h != 0 or ifm_dim_w % k_w != 0) and (not dim_1d):
         pytest.skip("Skipping StreamingMaxPool test w/ ImgDim % PoolDim != 0")
     if pe > ifm_ch:
         pytest.skip("SIMD cannot be larger than number of input channels")
@@ -166,12 +177,13 @@ def test_fpgadataflow_streamingmaxpool(idt, dim_1d, k, ifm_dim, ifm_ch, pe, exec
     # prepare input data
     input_dict = prepare_inputs(x)
 
-    golden = make_single_maxpoolnhwc_modelwrapper(k, ifm_ch, ifm_dim, ofm_dim, idt)
+    golden = make_single_maxpoolnhwc_modelwrapper(
+        k, ifm_ch, ifm_dim, ofm_dim, idt, ceil_mode
+    )
     y_expected = oxe.execute_onnx(golden, input_dict)["outp"]
 
-    model = make_single_streamingmaxpool_modelwrapper(
-        k, ifm_ch, pe, ifm_dim, ofm_dim, idt
-    )
+    model = golden.transform(InferStreamingMaxPool())
+    model = model.transform(InferShapes())
 
     if exec_mode == "cppsim":
         model = model.transform(SetExecMode("cppsim"))