Deployment and Maintenance / Benchmark Performance Testing

This Guide mainly introduces how to perform benchmark performance testing on DataFlux Func.

1. Preface

All example results in this Guide were tested in the following hardware environment:

	Description
Computer	HP ProBook Laptop
CPU	AMD Ryzen 5 7530U with Radeon Graphics / 4.5 GHz
Memory	32 GB / 3200 MHz (0.3 ns)
Operating System	Ubuntu 22.04.5 LTS

2. Benchmark Testing Package

Download Benchmark.zip and import it into DataFlux Func.

The Benchmark testing package contains the following:

Content	Description
Script Set benchmark
Function benchmark__main.hello_world	A function that directly returns "ok", used for concurrency testing
Function benchmark__main.json_dump	Performs JSON serialization / deserialization, used for performance testing
Function benchmark__main.calc_pi	Calculates pi, used for performance testing
Sync API benchmark-hello-world	Used for concurrency testing
Cron Job benchmark-hello-world	Used to test task scheduling performance
Cron Job benchmark-compute-pi	Used to test computational performance (calculating pi)
Cron Job benchmark-json-dump-and-load	Used to test computational performance (JSON serialization / deserialization)

3. Executing Tests

After importing the Benchmark testing package, since Cron Jobs run automatically, you can view the results in the task records after a few minutes.

However, concurrency performance testing for DataFlux Func requires the use of other tools.

3.1 Testing Task Scheduling Performance

After importing the Benchmark testing package, wait a few minutes and then view the results in the "Hello, World" task record under "Cron Jobs".

Generally, each task should take less than 10 milliseconds.

3.2 Testing Computational Performance

After importing the Benchmark testing package, wait a few minutes and then view the results in the "Compute pi" and "JSON dump and load" task records under "Cron Jobs".

In the test environment mentioned in the "Preface", each task takes around 1 second:

• Calculating pi "Compute pi"

• JSON serialization / deserialization "JSON dump and load"

3.3 Testing Func API Concurrency Performance

For concurrency performance testing, you can use the ab (ApacheBench) tool.

If ab is not installed, you can install it using the following commands:

Install via aptInstall via yum

apt-get install apache2-utils

yum install httpd-tools

Use ab to test the "Hello, World" function in the testing package with the following command:

Func on local machineFunc on another server

ab -c 10 -n 5000 -k http://localhost:8088/api/v1/sync/benchmark-hello-world

ab -c 10 -n 5000 -k http://{DataFlux Func IP or domain}:8088/api/v1/sync/benchmark-hello-world

In the test environment mentioned in the "Preface", the concurrency of the empty function is around 1000 (Requests per second):

# ab -c 10 -n 5000 -k http://localhost:8088/api/v1/sync/benchmark-hello-world
This is ApacheBench, Version 2.3 <$Revision: 1879490 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 500 requests
Completed 1000 requests
...
Completed 5000 requests
Finished 5000 requests


Server Software:
Server Hostname:        localhost
Server Port:            8088

Document Path:          /api/v1/sync/benchmark-hello-world
Document Length:        13 bytes

Concurrency Level:      10
Time taken for tests:   4.694 seconds
Complete requests:      5000
Failed requests:        0
Keep-Alive requests:    5000
Total transferred:      3045525 bytes
HTML transferred:       65000 bytes
Requests per second:    1065.17 [#/sec] (mean)
Time per request:       9.388 [ms] (mean)
Time per request:       0.939 [ms] (mean, across all concurrent requests)
Transfer rate:          633.60 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       1
Processing:     5    9   1.8      9      29
Waiting:        4    9   1.8      9      29
Total:          5    9   1.8      9      29

Percentage of the requests served within a certain time (ms)
  50%      9
  66%     10
  75%     10
  80%     10
  90%     12
  95%     13
  98%     14
  99%     15
  100%     29 (longest request)

4. Factors Affecting Performance

Since the actual execution content of tasks is determined by the scripts being called, if tasks take a long time to execute, you can check if the following issues exist in the code:

4.1 Excessive print(...)

For debugging convenience, some may directly output data from the DB or API responses using print(...).

Since DataFlux Func automatically records print(...) content during task execution, this can lead to significant performance degradation.

It is recommended to keep only necessary print(...) outputs in production code and avoid large text outputs.

4.2 Slow External System Responses

When querying external databases or calling API interfaces (including executing DQL queries) in scripts, network delays or slow responses from the external system can also cause tasks to take a long time to execute.

This is not related to DataFlux Func, and you should contact the responsible parties of these external systems to improve response speed.

Here is a simple example code to test processing time:

import time
import requests

def test():
    t1 = time.time()
    requests.get('http://github.com')
    print(f'Cost: {time.time() -  t1} s')