JarCasting
JarCasting JarCasting

ScaFi

An aggregate programming toolkit on the JVM

License

License
GroupId

GroupId

it.unibo.scafi
ArtifactId

ArtifactId

scafi-demos-distributed_2.13
Last Version

Last Version

0.3.3
Release Date

Release Date
Type

Type

pom.sha512
Description

Description

ScaFi
An aggregate programming toolkit on the JVM
Project URL

Project URL

https://scafi.github.io
Source Code Management

Source Code Management

https://github.com/scafi/scafi

Download scafi-demos-distributed_2.13

Filename Size
scafi-demos-distributed_2.13-0.3.3.pom
scafi-demos-distributed_2.13-0.3.3-sources.jar 35 KB
scafi-demos-distributed_2.13-0.3.3-javadoc.jar 261 bytes
Browse

Dependencies

runtime (3)

Group / Artifact Type Version
org.scala-lang : scala-library jar %scala-version%
it.unibo.scafi : scafi-stdlib-ext_2.13 jar 0.3.3
it.unibo.scafi : scafi-distributed_2.13 jar 0.3.3

Project Modules

There are no modules declared in this project.

ScaFi (Scala Fields)

ScaFi is a Scala-based library and framework for Aggregate Programming. It implements a variant of the Higher-Order Field Calculus (HOFC) operational semantics, which is made available as a usable domain-specific language (DSL), and provides a platform and API for simulating and executing Aggregate Computing systems and applications.

Please refer to the ScaFi main website and ScaFi Documentation the for further information.

Overview

Status Badges

Stable branch

Build Status

Development branch

Build Status

Notes for application developers

  • NOTE: scafi-core and scafi-simulator cross-target both the JVM and the JavaScript Platform (via Scala.js); however, packages for the latter are currently not released.

Import via Maven/sbt/Gradle

Add the dependency to scafi in your project, e.g., via sbt

// build.sbt
val scafi_version = "0.3.3"

val scafi_core  = "it.unibo.scafi" %% "scafi-core"  % scafi_version
val scafi_simulator  = "it.unibo.scafi" %% "scafi-simulator"  % scafi_version
val scafi_simulator_gui  = "it.unibo.scafi" %% "scafi-simulator-gui"  % scafi_version
val scafi_platform = "it.unibo.scafi" %% "scafi-distributed"  % scafi_version

libraryDependencies ++= Seq(scafi_core, scafi_simulator, scafi_platform)

or Gradle

// build.gradle.kts
dependencies {
    implementation("it.unibo.scafi:scafi-core_2.13:0.3.3")
}

Hello, ScaFi

As another example, consider the following steps.

Step 1: Import or define an incarnation (a family of types), from which you can import types like AggregateProgram

package experiments

// Method #1: Use an incarnation which is already defined
// (Note: BasicSimulationIncarnation is defined in module 'scafi-simulator')
import it.unibo.scafi.incarnations.BasicSimulationIncarnation.AggregateProgram

// Method #2: Define a custom incarnation and import stuff from it
object MyIncarnation extends it.unibo.scafi.incarnations.BasicAbstractIncarnation
import MyIncarnation._

Step 2: Define an AggregateProgram which expresses the global behaviour of an ensemble.

// An "aggregate program" can be seen as a function from a Context to an Export
// The Context is the input for a local computation: includes state 
//  from previous computations, sensor data, and exports from neighbours.
// The export is a tree-like data structure that contains all the information needed
//  for coordinating with neighbours. It also contains the output of the computation.
object MyAggregateProgram extends AggregateProgram {
  // Main program expression driving the ensemble
  // This is run in a loop for each agent
  // According to this expression, coordination messages are automatically generated
  // The platform/middleware/simulator is responsible for coordination
  override def main() = gradient(isSource)

  // The gradient is the (self-adaptive) field of the minimum distances from source nodes
  // `rep` is the construct for state transformation (remember the round-by-round loop behaviour)
  // `mux` is a purely functional multiplexer (selects the first or second branch according to condition)
  // `foldhoodPlus` folds over the neighbourhood (think like Scala's fold)
  // (`Plus` means "without self"--with plain `foldhood`, the device itself is folded)
  // `nbr(e)` denotes the values to be locally computed and shared with neighbours
  // `nbrRange` is a sensor that, when folding, returns the distance wrt each neighbour
  def gradient(source: Boolean): Double =
    rep(Double.PositiveInfinity){ distance =>
      mux(source) { 0.0 } {
        foldhoodPlus(Double.PositiveInfinity)(Math.min)(nbr{distance}+nbrRange)
      }
    }

  // A custom local sensor
  def isSource = sense[Boolean]("source")
  // A custom "neighbouring sensor"
  def nbrRange = nbrvar[Double](NBR_RANGE_NAME)
}

Step 3: Use ScaFi's internal simulator and GUI (modules scafi-simulator and scafi-simulator-gui, respectively) to run the program on a predefined network of devices.

import it.unibo.scafi.simulation.gui.{Launcher, Settings}

object SimulationRunner extends Launcher {
  Settings.Sim_ProgramClass = "experiments.MyAggregateProgram"
  Settings.ShowConfigPanel = true
  launch()
}

Alternatively, you can (a) implement your integration/middleware layer, or (b) leverages integration with the Alchemist simulator, for more sophisticated simulations. This and much more is described in the ScaFi Documentation Page.

ScaFi Architecture

From a deployment perspective, ScaFi consists of the following modules:

  • scafi-commons: provides basic entities (e.g., spatial and temporal abstractions)
  • scafi-core: represents the core of the project and provides an implementation of the ScaFi aggregate programming DSL, together with its standard library
  • scafi-simulator: provides a basic support for simulating aggregate systems
  • scafi-simulator-gui: provides a GUI for visualising simulations of aggregate systems
  • spala: provides an actor-based aggregate computing middleware
  • scafi-distributed: ScaFi integration-layer for spala

The modules to be imported (e.g., via sbt or Gradle) depend on the use case:

  • Development of a real-world aggregate application. Bring scafi-core in for a fine-grained integration. For more straightforward distributed system setup, take a look at scafi-distributed.
  • Play, exercise, and experiment with aggregate programming. Bring scafi-core in for writing aggregate programs as well as scafi-simulator-gui to quickly render an executing system.
  • Set up sophisticated simulations Bring scafi-core in for writing aggregate programs and either (A) leverage the basic machinery provided by scafi-simulator, or (B) leverage the ScaFi support provided by Alchemist.

Release Highlights

0.3.3 (2020-04-10)

  • Cross-compilation to Scala 2.13 (in addition to 2.11 and 2.12)
  • Gradle build in addition to the sbt build
  • 3D Renderer (by @AleGnucci)
  • New simulator GUI (by @cric96)
  • Handle serialization in spala and scafi-distributed (contribution by @manuelperuzzi)
  • Various library fixes and adjustments

NOTE: for versions below the project's group ID is it.unibo.apiceteam.scafi (rather than the current it.unibo.scafi)

0.3.2 (2018-10-19)

  • Aggregate processes with spawn constructs
  • Adjustments to operational semantics
  • Refactoring of modules (e.g., stdlib brought into core)
  • More features in the standard library
  • Bug fixes, tests, etc.

0.3.0 (2018-03-27)

  • stdlib module
  • align construct

0.2.0 (2017-06-28)

  • Several important adjustments to the core operational semantics (and more tests)
  • Refactoring of the field calculus interpreter
  • A basic graphical simulator (contribution by C. Varini) has been added as a separate module simulator-gui
  • Cross compilation for Scala 2.11 and 2.12

People

Main Researchers and Authors

  • Mirko Viroli
  • Roberto Casadei

Research Collaborators

  • Ferruccio Damiani
  • Giorgio Audrito

License

scafi is Open Source and available under the Apache 2 License.

it.unibo.scafi

scafi

Versions

Version
0.3.3