Dynamic Tasking

BeeCluster embraces dynamic task graph (DTG) as its core programming model, allowing your application to react to the environment by creating new tasks or canceling existing tasks dynamically.

Flexible Virtual Drones

BeeCluster provides a set of versatile abstractions mapping your virtual drones to physical drones. You can even define a virtual drone with infinite flying time in BeeCluster!

Predictive Optimization

BeeCluster forecasts your application's future behavior and optimizes the execution of your application transparently.

BeeCluster simplfies the development of drone applications.

The orchestration platform manages a fleet of drones and provides virtual drone service to the application developers. The application developers only need to focus on the high level application logic, while the underlaying orchestration platform takes care of the optimization and low-level drone controls. (learn more)

BeeCluster's programming interface is simple and flexible.

BeeCluster API is powered by dynamic task graph (DTG). Developers can use the API in many coding structures, and compose basic structures to express more complicated application logics. The runtime system can naturally capture the task dependency and parallelism, and use them to schedule drones efficiently. (learn more)

Programming Examples

For developers, we show a few coding examples here. You can try out these examples in our built-in simulator.

Create BeeCluster Sessions

import sys
sys.path.append('../python') # path to beecluster
import beecluster

# Session Creation Style 1
bc = beecluster.Session(appID = "TEST-0")
# do nothing 
bc.close()

# Session Creation Style 2
with beecluster.Session(appID = "TEST-0") as bc:
    # do nothing
    pass 

Box Pattern

import sys
sys.path.append('../python') # path to beecluster
import beecluster

def foo(bc):
    bc.act("flyto", (10,10,30))
    bc.act("flyto", (80,10,30))
    bc.act("flyto", (80,80,30))
    bc.act("flyto", (10,80,30))
    bc.act("flyto", (10,10,30))
    
    bc.wait()

    return

if __name__ == "__main__":
    with beecluster.Session(appID = "TEST-1") as bc:
        bc.newTask(foo, bc).wait()

Virtual Drone Binding

import sys
sys.path.append('../python') # path to beecluster
import beecluster 
import math 

# 
def visitOnePoint(bc, loc):
    bc.act("flyto", loc)
    bc.wait() 

    return

# test same drone but interruptible
def box(bc, n):
    bc.act("flyto", (10,10,30))
    
    for i in range(n):
        bc.act("flyto", (80,10,30))
        bc.act("flyto", (80,80,30))
        bc.act("flyto", (10,80,30))
        bc.act("flyto", (10,10,30))
    
        bc.wait() 
        print("box #%d",i)

    return h.val 

# test non-same drone but non-interruptible 
def circle(bc, r):
    for i in range(32):
        alpha = 2*3.1415926/32.0*i
        bc.act("flyto", (r * math.cos(alpha), r * math.sin(alpha),30)).wait()

        print("circle point #%d"%i)

    bc.wait()

    return

if __name__ == "__main__":
    ### require at least 2 drones in this test
    bc = beecluster.Session(appID = "TEST-2")

    h = bc.newTask(visitOnePoint, bc, (-20,-20,30))
    h.wait()

    h1 = bc.newTask(box, bc, 5, TaskName="box", NonInterruptible = False, SameDrone = True)
    h2 = bc.newTask(circle,bc, 50, TaskName="circle1", NonInterruptible = True, SameDrone = False)
    h3 = bc.newTask(circle,bc, 80, TaskName="circle2", NonInterruptible = True, SameDrone = False)

    h1.wait()
    h2.wait()
    h3.wait()

    bc.close()

Continuous Operation

####
# 
# Test continous operation (drone hand-off)
# Requires at least two drones in the simulator.
#
####

import sys
sys.path.append('../python') # path to beecluster
import beecluster
from time import time, sleep 
import math 
import numpy as np 


beecluster.ResetRemoteServer()
sleep(0.1)

# test non-same drone but non-interruptible 
def circle(bc, r):
    interval = []

    for i in range(32*4):
        alpha = 2*3.1415926/32.0*i
        bc.act("flyto", (r * math.cos(alpha), r * math.sin(alpha),30))
        h = bc.act("gp:sense", None)
        h.val 
        if i > 3:
            interval.append(time()-t0)

        t0 = time()
        print("circle point #%d"%i)

    bc.wait()

    print("max interval: ", np.amax(interval))
    print("average interval: ",np.mean(interval))
    print("interval std: ", np.std(interval))

    return (np.amax(interval), np.mean(interval), np.std(interval))



if __name__ == "__main__":
    bc = beecluster.Session(appID = "TEST-3")

    bc.newTask(circle, bc, 80, TaskName="circle2", NonInterruptible = True, SameDrone = False).wait()
    
    bc.close()


    assert result[0] < result[1]*3.0, "######## TEST-3  FAILED ######## Hand-off too slow!"


    print("######## TEST-3  PASSED ########")

Massive Parallel Tasks

import sys
sys.path.append('../python') # path to beecluster
import beecluster

# test non-same drone but non-interruptible 
def visit(bc, loc):
    bc.act("flyto", loc)
    bc.wait()


if __name__ == "__main__":
    bc = beecluster.Session(appID = "TEST-4")

    handles = []

    for x in range(-50,51,10):
        for y in range(-50,51,10):
            h = bc.newTask(visit, bc, (x,y,30), TaskName="visit")
            handles.append(h)

    results = [h.wait() for h in handles]

    bc.close(SaveDTG=False)

Failure Handling

import sys
sys.path.append('../python') # path to beecluster
import beecluster
from time import sleep 
# test error handling and override flags api 

def infinite_loop(bc):
    bc.setFlags(True, True)

    bc.act("flyto", (50,50,10))
    
    while True:
        bc.act("wifi:sense").val
        sleep(1.0)

if __name__ == "__main__":
    with beecluster.Session(appID = "TEST-5") as bc:

        def error_handler(e):
            print(e)

        # Test timeout 
        bc.newTask(infinite_loop, bc, TaskName="loop", error_handler = error_handler, timeout = 5.0).val 
        
        # Test binding violation 
        # The drone will run out of battery and return to home, this 
        # will trigger the binding violation.
        bc.newTask(infinite_loop, bc, TaskName="loop", error_handler = error_handler, timeout = None).val 
        

Real-World Case Studies

Mapping New Roads

WiFi Coverage Map

WiFi Hotspot Localization

Continuous Object Tracking

BeeCluster Presentation at MobiSys 2020 (Watch here ↓ or on youtube).

Cite This Work

The original research paper of this work was published at MobiSys 2020. Please use the following BibTex to cite this paper.

@inproceedings{he2020beecluster,
  title={BeeCluster: drone orchestration via predictive optimization.},
  author={He, Songtao and Bastani, Favyen and Balasingam, Arjun and Gopalakrishnan, Karthik and Jiang, Ziwen and Alizadeh, Mohammad and Balakrishnan, Hari and Cafarella, Michael J and Kraska, Tim and Madden, Sam},
  booktitle={MobiSys},
  pages={299--311},
  year={2020}
}
  

Build cross-platform and optimized drone applications.

BeeCluster drone orchestration platform.