Home

This page is an accompaniment to the paper Skylines for Symbolic Energy Consumption Analysis. Below we present a number of SECA programs along with their skylines. An extended version of the paper and the implementation of the tool are also available.

Line Follower Robot

A somewhat larger example, implementing a line follower robot. See page LineFollower.

Code with a bug

int main() {
  x=SENS.readTemp();
  if( x <= 10 ) {
    LED1.switchOn();
  } else {
    LED2.switchOn();
  }
  sleep(100);
  if( x < 10 ) {
    LED1.switchOff();
  } else {
    LED2.switchOff();
  }
  return 0;
}

int sleep(int n)
{
  return n;
}

Code with common initial segment

int main() {
  LED1.switchOn();
  LED2.switchOn();
  if( TERM.readInt() <= 5 ) {
    LED1.switchOff();
  }
  else {
    LED2.switchOff();
  }
  return 0;
}

Code with common final segment

int main()
{
  x = TERM.readInt();

  if( x <= 5 )
  {
    LED1.switchOn();
    LED1.switchOff();
  }
  else
  {
    LED2.switchOn();
    LED2.switchOff();
  }

  LED1.switchOn();
  LED1.switchOff();

  LED2.switchOn();
  LED2.switchOff();

  return 0;
}

Code with common initial and final segments

int main() {
  x = TERM.readInt();
  LED3.switchOn();
  if( x <= 5 ) {
    LED1.switchOn();
    LED1.switchOff();
  } else {
    LED2.switchOn();
    LED2.switchOff();
  }
  LED3.switchOff();
  return 0;
}

A program with three execution paths

Infeasible paths are omitted by the symbolic execution.

int main()
{
  x = TERM.readInt();

  if( x <= 5 )
  {
    LED1.switchOn();
    LED1.switchOff();
  }
  else
  {
    LED2.switchOn();
    LED2.switchOff();
  }

  if( x <= 10 )
  {
    LED1.switchOn();
    LED1.switchOff();
  }
  else
  {
    LED2.switchOn();
    LED2.switchOff();
  }

  return 0;
}

Programs with loops

The following programs all use a loop.

A loop that changes after two iterations

int main()
{
  x = TERM.readInt();
  while( 0 <= x && x <= 3 )
  {
    if( x <= 1 )
    {
      LED1.switchOn();
      LED1.switchOff();
    }
    else
    {
      LED2.switchOn();
      LED2.switchOff();
    }
    x = x + 1;
  }

  return 0;
}

A loop with alternating behaviour in different iterations

int main() {
  y = 1;
  x = TERM.readInt();
  while( 0 <= x && x <= 4 ) {
    if( y <= 0 ) {
      LED1.switchOn();
      LED2.switchOff();
    }
    else {
      LED2.switchOn();
      LED1.switchOff();
    }
    y = y * -1;
    x = x + 1;
  }
  return 0;
}

A nested pair of loops

int main()
{
x = TERM.readInt();
  while( 0 <= x && x <= 1 )
  {
    y = TERM.readInt();
    while( 0 <= y && y <= 1 )
    {
      LED1.switchOn();
      LED1.switchOff();
      y = y + 1;
    }

    LED2.switchOn();
    LED2.switchOff();
    x = x + 1;
  }

  return 0;
}

A function with many evaluation paths

int max = 3;


int main()
{

  y = 1;
  z = TERM.readInt();
  x = z;
  while( 0 <= x && x <= max )
  {
    if( y <= 0 )
    {
      LED1.switchOn();
      LED2.switchOff();
    }
    else
    {
      LED2.switchOn();
      LED1.switchOff();
    }

    y = y * -1;
    x = x + 1;
  }




  z = TERM.readInt();
  x = z;
  while( 0 <= x && x <= max )
  {
    if( y <= 0 )
    {
      LED1.switchOn();
      LED2.switchOff();
    }
    else
    {
      LED2.switchOn();
      LED1.switchOff();
    }

    y = y * -1;
    x = x + 1;
  }





  z = TERM.readInt();
  x = z;
  while( 0 <= x && x <= max )
  {
    if( y <= 0 )
    {
      LED1.switchOn();
      LED2.switchOff();
    }
    else
    {
      LED2.switchOn();
      LED1.switchOff();
    }

    y = y * -1;
    x = x + 1;
  }



  return 0;

}

Programs with function calls

The following programs all employ a function call.

A recursive function

int main()
{
  x = TERM.readInt();
  loop(x);
  return 0;
}

int loop(int x)
{
  if( onOff(x) )
  {
    loop(x + 1);
    return 0;
  }
  else
  {
    return 0;
  }
}

bool onOff(int x)
{
  if( x == 0 )
  {
    LED1.switchOn();
    return true;
  }
  else if( x == 1 )
  {
    LED2.switchOn();
    return true;
  }
  else if( x == 2 )
  {
    LED3.switchOn();
    return true;
  }
  else if( x == 3 )
  {
    LED3.switchOff();
    return true;
  }
  else if( x == 4 )
  {
    LED2.switchOff();
    return true;
  }
  else if( x == 5 )
  {
    LED1.switchOff();
    return true;
  }
  else
  {
    return false;
  }
}

A loop condition with side effect

int main()
{
  i = 0;
  while(
      foo(i))
  {
    i = i + 1;
  }

  return 0;
}

bool foo(int i)
{
  if( i < 10 )
  {
    LED1.switchOn();
    return true;
  }
  else
  {
    LED1.switchOff();
    return false;
  }
}

Demonstrating the filter option

A given function may be called from multiple places in the program, in varying states of energy consumption.

Thus, a function that enables a single LED could have a dozen different skylines all depending on the states of other components that are not relevant to this function.

Depending on the application, it may be desirable to view only the energy consumption of components that are relevant to the given function. Here, a component is relevant to a function f if either there is a component call to it in f, or f calls a different function g and the component is relevant to g.

In our tool, we support this by allowing a filtering option --filter-components. The resulting skylines are presented below.

A simple example

// The same function called in different states

int foo()
{
  LED1.switchOn();
  LED1.switchOff();
  return 0;
}


int main()
{
  foo();
  LED2.switchOn();
  foo();
  LED2.switchOff();
  foo();
  return 0;
}

A function call with parameters

int foo(bool on)
{
  if( on )
  {
    LED1.switchOn();
  }
  else
  {
    LED1.switchOff();
  }

  return 0;
}

int main()
{
  foo(true);


  LED2.switchOn();



  foo(false);




  LED2.switchOff();
  return 0;
}