EdgeFlow is a new methodology for latency-sensitive IoT applications development and deployment. We propose EdgeFlow in the paper “EdgeFlow - Developing and Deploying Latency-Sensitive IoT Edge applications”.

EdgeFlow methodology Overview

The figure below provides an overview of our methodology to develop and deploy latency-sensitive IoT applications on an edge computing platform. The EdgeFlow methodology consists of three stages, i.e., (i) the development stage, (ii) the deployment stage, and (iii) the validation stage. At design time, the application developer can use the development stage to model the application and provide specific resource and timing requirements. In the end, the developer generates the application model and all its requirements into two JSON files, i.e., (i) the application model file and (ii) the flow constraints file. Furthermore, the developer must prepare the edge computing platform file. With the three files ready, the developer employs the deployment stage to validate and find an optimal or feasible deployment strategy.

EdgeFlow methodology: Overview.

Development Stage

To prove the benefits of creating a new latency-sensitive application using EdgeFlow, we develop an application development prototype as an extension to drawFBP. DrawFBP uses Flow-Based Programming (FBP) at its core and allows developers to create application models using blocks, i.e., components.


The developer can use our application development prototype to create new latency-sensitive applications by defining timing and resource requirements and connect multiple components. FBP is not a coding language; therefore, the ideal development process would be to use predefined components from a library. If needed, the application developer can develop new components in another programming language.

In this part, we provide the instructions to develop the motivational example, i.e., the public safety application, as we did in the Application Development methodology section. We mention that we use did not implement the componenents, since this is out of the scope of the current paper.

The following archive, Application Development stage, contains the development application prototype and the public safety application components. Specifically, in the folder, you will find two JAR files, i.e., developmentStage.jar which is our prototype and javafbp.jar for the create new components in java. Note that we do not extend or modify javaFBP, we have used the standard version from https://github.com/jpaulm/javafbp to create the EdgeFlow components. Besides the two JARs, there are two folders, i.e., componentsExamples and ProjectsFBP. The former contains the EdgeFlow components, while the latter has the public safety application model with no timing and resource requirements assigned.

Steps to develop the Public Safety application model and generate the two JSON files:

  1. Download and extract the application development prototype to the desired location.
  2. To start the development process, execute the developmentStage.jar. Be aware that you must give permission to execute JAR files on your system. Otherwise, it will not open.
  3. Add the javaFBP.jar to the project. Go to File menu -> Locate JavaFBP Jar file and add the path to the javaFBP.jar from the local directory.
  4. Go to File -> Open Diagram and select PublicSafetyApplication.drw.drw from ProjectsFBP folder.
  5. Add the components functionality: component menu -> Choose Component/Subnet Class. To access the component menu, right click on the target component. To select a class go to localdir/componentsExamples/classes/com/jpaulmorrison/fbp/core/components/edgeflow. Repeat this step until all comonents have a class.
  6. Add components requirements: component menu -> Set Components Requirements. To display all requirements select Display Component Info.
  7. Add flow constraints for the application from: File menu -> Set flow constraints. Use the flow constraint format presented in the paper when creating new flows. To display the flows use Display flow constraints. To change a flow create a new one using the same ID and to delete a flow use the option File menu -> Delete flow constraints passing the flow ID.
  8. Generate the two JSON files: File menu -> Application model: generate JSON file and Flow Constraints: generate JSON file. The files are saved into the results folder at the same location where the JAR file is.

Deployment Stage

To demonstrate the capabilities of our proposed resource allocation technique we perform a quantitative evaluation. We measure the execution time required to build the CP model and solve it using a CP solver for different scenarios. In this part, we provide the utilization intructions to find an optimal deployment strategy for the Public Safety application model we have created with the development stage. The deployment technique receives as input the three input JSON files, i.e., flow constraints, application model, and edge computing plaftform.

The archive containing the deployment stage can be found at: Deployment stage technique


Steps to validate the Public Safety application's requirements and find a deployment strategy:

  1. Download and extract the deployment stage to the desired location. In this folder we can find all inputs files used during the evaluation. All files required to find a deployment strategy for the Public Safety application can be found in the inputFiles folder. The flow_constraints_publicSafety.json and application_model_publicSafety.json files are generated from the development stage, while the edge_platform_publicSafety.json is created with other external methods.
  2. First, make sure the following are installed: Google OR-Tools and python 3.7.
  3. To start the deployment process, open a terminal window and navigate to location/DeploymentStage/edgeresaloc, where location represents the path to the deploymentStage folder.
  4. Execute: python3 deployment.py -h to see all options supported by our deployment technique.
  5. To find a deployment stategy for the Public Safety Application execute the following:
    python3 deployment.py -a "application_model_publicSafety" -e "edge_platform_publicSafety" -f "flow_constraints_publicSafety" -o -r "results_publicSafetyApp"

Following the steps will find a deployment strategy for the Public Safety Application. The deployment strategy is saved in results_publicSafetyApp.txt found in the results folder.

Finally, the results of our evaluation for all scenarios are presented in Results.