SYBL: Simple Yet Beautiful Language

 

SYBL is a language enabling elasticity requirements description for cloud applications.

SYBL can be used by cloud providers, software providers, application developers or even end-users to describe their elasticity requirements concerning the application. The language allows for different levels of specification facilitating finer-grained elasticity specifications and enforcement depending on the actual needs of the users.

SYBL enables different levels at which users can specify elasticity requirements: application, component and programming. Application level allows for elasticity from the perspective of the whole application, while component-level and code-level elasticity requirements define user's elasticity needs for component, and respectively, sequnces of code.

  • SYBL Backus–Naur Form (BNF)

    Constraint := constraintName : CONSTRAINT ComplexCondition 
Monitoring := monitoringName : MONITORING varName=MetricFormula 
Strategy := strategyName : STRATEGY WHEN ComplexCondition : action(parameterList)|  
		strategyName : STRATEGY WAIT ComplexCondition| 
		strategyName : STRATEGY STOP| 
		strategyName : STRATEGY RESUME		 
    
MetricFormula := metric | number | metricFormula MathOperator metric | metricFormula 
		MathOperator number 
ComplexCondition := Condition | ComplexCondition BitwiseOperator Condition|
		(ComplexCondition BitwiseOperator Condition) 
Condition := metric RelationOperator number| number RelationOperator metric | 
	    Violated(name)|Fulfilled(name) 
MathOperator := + | - | * | / 
BitwiseOperator := OR | AND | XOR | NOT 
RelationOperator := <|>|>=|<=|==|!=

Examples of using SYBL

Cost-related elasticity requirements

  • A cloud customer can specify that when the total cost is higher than 800 euro, there should be a scale-in action for keeping costs in acceptable limits. 
    @SYBL_ApplicationContext(strategies="St1: STRATEGY CASE total_cost>800 Euro : ScaleIn")

Quality-related elasticity requirements

  • A software provider can specify constraints on the response time depending on the number of users currently accessing the provided software. 
    @SYBL_ComponentContext(constraints=
	"Co1: CONSTRAINT rt<2ms WHEN nbUsers<1000;
	Co2: CONSTRAINT rt<4ms WHEN nbUsers>=1000")
  • A developer could specify that the result from a data analytics algorithm must reach a certain data accuracy under a cost constraint without caring how many resources should be used for executing the code of that algorithm. 
    @SYBL_ProgrammingContext(constraints=
	"Co1: CONSTRAINT dataAccuracy>90%; 
	Co2:CONSTRAINT dataAccuracy>95% WHEN total_cost>400;
	Co3:CONSTRAINT total_cost<800;"
priorities=
	"Priority(Co2)>Priority(Co1);
	Priority(Co3)>Priority(Co1);")

Elasticity requirements on the relation between cost and quality

  • A cloud provider could specify its pricing schema or price computation policies, for example that when availability is higher than 99% the cost should increase by 10%. 
    @SYBL_ApplicationContext(strategies="St1: STRATEGY CASE availability>99%: IncreaseCostBy(total_cost/10)")

SYBL Runtime System

SYBL Runtime System

Programming Level Elasticity Specifications

The following SYBL annotation describe elasticity requirements with a special focus on the data side of the application, which in this case is a NoSql database. 

@SYBL_ProgrammingContext(type=AnnotType.DURING,
	constraints="Co1:CONSTRAINT cpuUsageData < 65;
		Co2: CONSTRAINT cpuUsageData > 30;
		Co3: CONSTRAINT cpuUsageData < 85 WHEN cost > 70;
	monitoring="Mo1:MONITORING cost = cost.instant;
		Mo2: MONITORING dataThroughput = throughput.datasource;
		Mo3: MONITORING cpuAllocatedData = cpu.size.datasource;
		Mo4: MONITORING cpuUsage = cpu.usage;
		Mo5: MONITORING cpuUsageData = cpu.usage.datasource",
	strategies="St1:STRATEGY CASE Violated(Co2): scaleInDataSource;
		St2: STRATEGY CASE Enabled(Co1) AND Violated(Co1): scaleOutDataSource;
		St3: STRATEGY CASE Enabled(Co3) AND Violated(Co3): scaleOutDataSource;"
	priorities="Priority(Co3) > Priority(Co1)")

Results

Enforcing the above SYBL annotations we get the following elasticity evolution:

Elasticity Space

Publications

  • SYBL: an Extensible Language for Controlling Elasticity in Cloud Applications (PDF), the 13th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing - CCGRID2013, to be held in Delft, the Netherlands, on May 14-16, 2013. (Accepted)
  • Schahram Dustdar, Yike Guo, Rui Han, Benjamin Satzger, Hong Linh Truong: Programming Directives for Elastic Computing. IEEE Internet Computing 16(6): 72-77 (2012)

Contact

If you need any further information please contact Georgiana Copil.

Prototypes Overview

 

... back to prototypes