Building blocks for aggregate programming of self-organising applications
0 likes•1,258 views
The document discusses building blocks for aggregate programming in self-organizing applications, focusing on creating reliable and adaptive distributed systems. It presents various examples and algorithms for managing crowd dynamics and devices in distributed networks, emphasizing implicit communication and adaptation strategies. The proposed framework leverages field calculus for implementation, allowing for robust and composable methods in complex applications.
![Foundation: Field Calculus
Variable
Literal Value Local Ops
Abstract & Call
Functions
State
Communication
Domain Change
[Viroli et al., ’13]
• Aggregate/local coherence, space-time
universal
• Too low level, no adaptivity guarantees](https://image.slidesharecdn.com/beal-140917071321-phpapp01/85/Building-blocks-for-aggregate-programming-of-self-organising-applications-7-320.jpg)
Building blocks for aggregate programming of self-organising applications
- 1. Building blocks for aggregate programming of self-organising applications Jacob Beal, Mirko Viroli FoCAS Workshop 8th IEEE SASO September, 2014
- 2. Goal: Reliable Distributed Adaptive Systems device neighborhood Field-based Computing Models Self-Organization Building Blocks Lots of distributed applications!
- 3. Example: Services for Mass Events 3
- 4. Example: Managing Crowd Danger
- 5. Device-Centric Programming Dispersal Advice Congestion-Aware Navigation Dangerous Density Warning Crowd Estimation • Explicit design of adaptation and communication • Complex per-device multi-service application • Intractable to ensure correct behavior
- 6. Dispersal Advice Dangerous Density Warning Aggregate Programming Congestion-Aware Navigation Crowd Estimation • Implicit adaptation and communication • Code each service independently • Compose via scope and information flow
- 7. Foundation: Field Calculus Variable Literal Value Local Ops Abstract & Call Functions State Communication Domain Change [Viroli et al., ’13] • Aggregate/local coherence, space-time universal • Too low level, no adaptivity guarantees
- 8. From Principle to Practice: Applications Distributed Library APIs Building blocks Core Calculus Transparent use of robust distributed algorithms Programmer level: lots of useful, intuitive methods Domain-specific APIs Provable robustness, scalability, composability Provable universality, aggregate/local relation unlimited uses many algorithms 5-20 combinators 5 operators
- 9. Making a library of building blocks: Time-decay All compositions are self-stabilizing Converge-cast Gradient-path-integral Sparse-choice if
- 10. Building Block: G Information spreading Field Calculus Implementation: (def G (source initial metric accumulate) (2nd (rep distance-value (tuple infinity initial) (mux source (tuple 0 initial) (min-hood (tuple (+ (1st (nbr distance-value)) (metric)) (accumulate (2nd (nbr distance-value))))))))) Library Examples: (def distance-to (source) (G source 0 nbr-range (fun (v) (+ v (nbr-range))))) (def broadcast (source value) (G source value nbr-range identity))
- 11. Building Block: C Information collection Field Calculus Implementation: (def C (potential accumulate local null) (rep v local (accumulate local (accumulate-hood accumulate (mux (= (nbr (find-parent potential)) (uid)) (nbr v) null))))) (def find-parent (potential) (mux (< (1st (min-hood (nbr potential))) potential) (2nd (min-hood (nbr (tuple potential (uid))))) NaN)) Library Examples: (def summarize (sink accumulate local null) (broadcast sink (C (distance-to sink) accumulate local null))) (def average (sink value) (/ (summarize sink + value 0) (summarize sink + 1 0)))
- 12. Building Block: T Time-summarization of information Field Calculus Implementation: (def T (initial decay) (rep v initial (min initial (max 0 (decay v))))) Library Examples: (def timer (length) (T length (fun (t) (- t (dt))))) (def limited-memory (value timeout) (2nd (T (tuple timeout value) 3 1 1 (fun (t) (tuple (- (1st t) (dt)) (2nd t)))))) 4 3 7 3 0 2
- 13. Building Block: S Choice of sparse subset Field Calculus Implementation: (def S (grain metric) (break-using-uids (random-uid) grain metric)) (def random-uid () (rep v (tuple (rnd 0 1) (uid)) (tuple (1st v) (uid)))) (def break-using-uids (uid grain metric) (= uid (rep lead uid (distance-competition (G (= uid lead) 0 metric (fun (v) (+ v (metric)))) lead uid grain metric)))) (def distance-competition (d lead uid grain metric) (mux (> d grain) uid (mux (>= d (* 0.5 grain)) infinity (min-hood (mux (>= (+ (nbr d) (metric)) (* 0.5 grain)) infinity (nbr lead))))))
- 14. Building Block: if Restrict scope to subspaces Field Calculus Implementation: (if test true-expression false-expression) Library Examples: (def distance-avoiding-obstacles (source obstacles) (if obstacles infinity (distance-to source))) (def recent-event (event timeout) (if event true (> (timer timeout) 0)))
- 15. Applying building blocks: Example API algorithms from building blocks: distance-to (source) max-likelihood (source p) broadcast (source value) path-forecast (source obstacle) summarize (sink accumulate local null) average (sink value) integral (sink value) region-max (sink value) timer (length) limited-memory (value timeout) random-voronoi (grain metric) group-size (region) broadcast-region (region source value) recent-event (event timeout) distance-avoiding-obstacles (source obstacles) Since based on these 5 building blocks, all programs built this way are self-stabilizing!
- 16. Complex Example: Crowd Management (def crowd-tracking (p) ;; Consider only Fruin LoS E or F within last minute (if (recently-true (> (density-est p) 1.08) 60) ;; Use S to break into ‘‘cells’’ and estimate danger of each (+ 1 (dangerous-density (S 30) p)) 0)) (def recently-true (state memory-time) ;; Make sure first state is false, not true... (rt-sub (not (T 1 1)) state memory-time)) (def rt-sub (started s m) (if state 1 (limited-memory s m))) (def dangerous-density (partition p) ;; Only dangerous if above critical density threshold... (and (> (average partition (density-est p)) 2.17) ;; ... and also involving many people. (> (summarize partition + (/ 1 p) 0) 300))) (def crowd-warning (p range) (> (distance-to (= (crowd-tracking p) 2)) range) (def safe-navigation (destination p) (distance-avoiding-obstacles destination (crowd-warning p))) 18 lines non-whitespace code 10 library calls (18 ops) IF: 3 G: 9 C: 3 T: 2 S: 1
- 17. Contributions • Composable algebra of building block algorithms • Terse enough to prove universal self-stabilization • Applicable to a broad range of adaptive distributed systems Lots of details in our tutorial this afternoon!