Benchmark Simple

1import depthai as dai
2
3device= dai.Device()
4
5with dai.Pipeline(device) as p:
6    # Create a BenchmarkOut node
7    # It will listen on the input to get the first message and then send it out at a specified rate
8    # The node sends the same message out (creates new pointers), not deep copies.
9    benchmarkOut = p.create(dai.node.BenchmarkOut)
10    benchmarkOut.setRunOnHost(True) # The node can run on host or on device
11    benchmarkOut.setFps(30)
12
13    # Create a BenchmarkIn node
14    # This node is receiving the messages on the input and measuring the FPS and latency.
15    # In the case that the input is with BenchmarkOut, the latency measurement is not always possible, as the message is not deep copied,
16    # which means that the timestamps stay the same and latency virtually increases over time.
17    benchmarkIn = p.create(dai.node.BenchmarkIn)
18    benchmarkIn.setRunOnHost(False) # The node can run on host or on device
19    benchmarkIn.sendReportEveryNMessages(100)
20    benchmarkIn.logReportsAsWarnings(False)
21    benchmarkIn.setLogLevel(dai.LogLevel.TRACE)
22
23    benchmarkOut.out.link(benchmarkIn.input)
24    outputQueue = benchmarkIn.report.createOutputQueue()
25    inputQueue = benchmarkOut.input.createInputQueue()
26
27    p.start()
28    imgFrame = dai.ImgFrame()
29    inputQueue.send(imgFrame)
30    while p.isRunning():
31        benchmarkReport = outputQueue.get()
32        assert isinstance(benchmarkReport, dai.BenchmarkReport)
33        print(f"FPS is {benchmarkReport.fps}")

1#include <iostream>
2
3#include "depthai/depthai.hpp"
4
5int main() {
6    // Create pipeline without implicit device
7    dai::Pipeline pipeline;
8
9    // Create a BenchmarkOut node
10    // It will listen on the input to get the first message and then send it out at a specified rate
11    // The node sends the same message out (creates new pointers), not deep copies.
12    auto benchmarkOut = pipeline.create<dai::node::BenchmarkOut>();
13    benchmarkOut->setRunOnHost(true);  // The node can run on host or on device
14    benchmarkOut->setFps(30);
15
16    // Create a BenchmarkIn node
17    // This node is receiving the messages on the input and measuring the FPS and latency.
18    // In the case that the input is with BenchmarkOut, the latency measurement is not always possible, as the message is not deep copied,
19    // which means that the timestamps stay the same and latency virtually increases over time.
20    auto benchmarkIn = pipeline.create<dai::node::BenchmarkIn>();
21    benchmarkIn->setRunOnHost(true);  // The node can run on host or on device
22    benchmarkIn->sendReportEveryNMessages(100);
23    benchmarkIn->logReportsAsWarnings(false);
24    benchmarkIn->setLogLevel(dai::LogLevel::TRACE);
25
26    benchmarkOut->out.link(benchmarkIn->input);
27    auto outputQueue = benchmarkIn->report.createOutputQueue();
28    auto inputQueue = benchmarkOut->input.createInputQueue();
29
30    pipeline.start();
31    auto imgFrame = std::make_shared<dai::ImgFrame>();
32    inputQueue->send(imgFrame);
33    while(pipeline.isRunning()) {
34        auto benchmarkReport = outputQueue->get<dai::BenchmarkReport>();
35        std::cout << "FPS is " << benchmarkReport->fps << std::endl;
36    }
37
38    return 0;
39}