Erlang Open Telecom Platform EAB/UPD/S Ulf Wiger

Contents Background The Erlang Language OTP The Erlang/OTP Test Server Experiences

Background

The Erlang Language

OTP

The Erlang/OTP Test Server

Experiences

History of Erlang 1984-86: Experiments programming POTS with several languages 1998: Open Source Erlang 1987: Early Erlang Prototype projects 1991: First fast implementation 1993: Distributed Erlang 1995: Several new projects 1996: Open Telecom Platform AXD and GPRS started How to design SW for future telecoms systems?

Erlang “Hello World” program io:format(“Hello, World~n”). Hello, World ok io:format(“Hello, ~s!~n”, [“Zvi”]). Hello, Zvi ok NOTE: “~s” instead of “%s”, like in printf in C. and “~n” instead of “
”.

io:format(“Hello, World~n”).

Hello, World

ok

io:format(“Hello, ~s!~n”, [“Zvi”]).

Hello, Zvi

ok

NOTE: “~s” instead of “%s”, like in printf in C.

and “~n” instead of “
”.

Erlang Data Types Atoms: true, false, inject_slice, zvi@home, ‘EXIT’, ‘+’ Integers ( only big integers allocated on the heap ) 10, -100, 1234567890999999999999999999999 2#101 = 5 16#FF = 255 $A = 65 (i.e. ASCII code of character ‘A’) Floats ( floats allocated on the heap – bad for HPC) 3.1415, 1.0, -1.7e-9 Tuples: {{1,2,3}, {a,b,c}, {{1,2,{a,b,c},{}} Lists: [[1,2,3], [a,b,c], [[1,2,[a,b,c],[]]

Atoms:

true, false, inject_slice, zvi@home, ‘EXIT’, ‘+’

Integers ( only big integers allocated on the heap )

10, -100, 1234567890999999999999999999999

2#101 = 5

16#FF = 255

$A = 65 (i.e. ASCII code of character ‘A’)

Floats ( floats allocated on the heap – bad for HPC)

3.1415, 1.0, -1.7e-9

Tuples:

{{1,2,3}, {a,b,c}, {{1,2,{a,b,c},{}}

Lists:

[[1,2,3], [a,b,c], [[1,2,[a,b,c],[]]

Erlang Data Types (2) String is a list of ASCII codes: “ hello” = [$h,$e,$l,$l,$o] = [104,101,108,108,111] Binaries (sequence of bytes): <<104,101,108,108,111>> = <<“hello”>> Binaries with Bit-Syntax: <<1:1,32787:15>> = 2#1111111111111111 Other data types: Funs (anonymous functions – closures) ProcessID Port etc.

String is a list of ASCII codes:

“ hello” = [$h,$e,$l,$l,$o] = [104,101,108,108,111]

Binaries (sequence of bytes):

<<104,101,108,108,111>> = <<“hello”>>

Binaries with Bit-Syntax:

<<1:1,32787:15>> = 2#1111111111111111

Other data types:

Funs (anonymous functions – closures)

ProcessID

Port

etc.

Pattern Matching and Single Assignment

List Operations

List Operations (2)

List Comprehensions

Anonymous Functions

Functions (cont.)

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Functional programming language High abstraction level Pattern matching Concise readable programs

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Solid concurrency model Scales to handle complex concurrency Simple abstractions Examples...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Erlang Example Creating a new process using spawn -module(ex3). -export([activity/3]). activity(Name,Pos,Size) -> ………… Pid = spawn(ex3,activity,[Joe,75,1024]) activity(Joe,75,1024)

Erlang Example Processes communicate by asynchronous message passing Pid ! {data,12,13} receive {start} -> ……… {stop} -> ……… {data,X,Y} -> ……… end receive {start} -> ……… {stop} -> ……… {data,X,Y} -> ……… end

Erlang Examples 4 Concurrency - Finite State Machine ringing_B_side(PidA) -> receive {lim, offhook} -> lim:stop_ringing(), PidA ! {hc, {connect, self()}}, speech(PidA); {hc, {cancel, PidA}} -> cancel(PidA); {lim, {digit, _Digit}} -> ringing_B_side(PidA); {hc, {request_connection, Pid}} -> Pid ! {hc, {reject, self()}}, ringing_B_side(PidA) after 30000 -> cancel(PidA) end. Selective receive True encapsulation of sub-states Optional timeout Asynchronous send

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Lightweight processes Fast message passing Response times in the order of milliseconds efficient garbage collection Numbers...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Process creation times (LOG/LOG scale) Source: Joe Armstrong SICS > 200,000 processes 10 100 1,000 10,000 100,000 Number of processes 1 10 100 1,000 Microseconds/process erlang java C#

Message passing times (LOG/LOG scale) Source: Joe Armstrong SICS > 200,000 processes 10 100 1,000 10,000 100,000 Number of processes 1 10 1,000 100,000 Microseconds/message erlang java C# 10,000 100 1

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Simple and consistent error recovery Supervision hierarchies &quot;Program for the correct case&quot; Examples...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Erlang Example Cooperating processes may be linked together using spawn_link(…,…,…) or link(Pid)

Erlang Example When a process terminates, an exit signal is sent to all linked processes … and the termination is propagated

Erlang Example Exit signals can be trapped and received as messages receive {‘EXIT’,Pid,...} -> ... end process_flag(trap_exit,true), ...

Erlang Example Robust systems can be built by layering “ Supervisors” “ Workers”

Error-handling -- Language Safety No global variables -- fewer side-effects No direct memory access -- no pointer errors No malloc/free bugs Solid concurrency model -- reduces synchronization problems, reduces the state space ( simpler programs ) Fault isolation -- memory-protected lightweight processes Built-in error recovery support -- more consistency Concurrency & Fault Tolerance were designed into the language from the start!

No global variables -- fewer side-effects

No direct memory access -- no pointer errors

No malloc/free bugs

Solid concurrency model -- reduces synchronization problems, reduces the state space ( simpler programs )

Fault isolation -- memory-protected lightweight processes

Built-in error recovery support -- more consistency

Debugging and Profiling Support Symbolic crash reports Usually sufficient info to locate bugs within minutes Built-in trace support Function calls (ability to filter on module name, function and args) Messages (+ sequence trace) Process events (context switch, spawn, link, exit) Garbage collections Optionally with timestamps (can be used for profiling, benchmarks) Trace to process, file, or port (network socket) Also available on live systems

Symbolic crash reports

Usually sufficient info to locate bugs within minutes

Built-in trace support

Function calls (ability to filter on module name, function and args)

Messages (+ sequence trace)

Process events (context switch, spawn, link, exit)

Garbage collections

Optionally with timestamps (can be used for profiling, benchmarks)

Trace to process, file, or port (network socket)

Also available on live systems

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Explicit or transparent distribution Network-aware runtime system Examples...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Transparent Distribution Erlang Run-Time System Erlang Run-Time System B ! Msg network C ! Msg Message passing between processes in different computer is just as easy as between processes in the same computer A B C

Simple RPC loop() -> receive {From, {apply, M, F, A}} -> Answer = (catch apply(M, F, A)), From ! {rex, node(), Answer} loop(); _Other -> loop() end. {rex, Node} ! {self(), {apply, M, F, A}}, receive {rex, Node, What} -> What end {rex, Node} ! {self(), {apply, M, F, A}}, receive {rex, Node, What} -> What end {rex, Node} ! {self(), {apply, M, F, A}}, receive {rex, Node, What} -> What end loop() -> receive {From, {apply, M, F, A}} -> Answer = (catch apply(M, F, A)), From ! {rex, node(), Answer} loop(); _Other -> loop() end. loop() -> receive {From, {apply, M, F, A}} -> Answer = (catch apply(M, F, A)), From ! {rex, node(), Answer} loop(); _Other -> loop() end. loop() -> receive {From, {apply, M, F, A}} -> Answer = (catch apply(M, F, A)), From ! {rex, node(), Answer} loop(); _Other -> loop() end.

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Easily change code in a running system Enables non-stop operation Simplifies testing Examples...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Erlang Example Version 1 Version 2 change_code

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability &quot;Ports&quot; to the outside world behave as Erlang processes (c.f. UML ports) Examples...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Erlang Example Port External process Port ! {self(), {command, [1,2,3]}}

Erlang Example Port External process receive {Port, {data, Info}} -> end A port can use e.g. a TCP, UDP, SSL socket, UNIX pipe, or custom transport (e.g. SAAL)

Erlang Highlights Declarative Concurrency Soft real-time Robustness Distribution Hot code loading External interfaces Portability Erlang runs on any UNIX, Windows, VxWorks, OSE Delta Supports heterogeneous networks Illustration...

Declarative

Concurrency

Soft real-time

Robustness

Distribution

Hot code loading

External interfaces

Portability

Systems Overview OTP Components Standard Libraries Erlang Run-Time System Hardware and Operating System Applications written in Erlang Applications written in C, C++ or Java

Erlang/OTP (Open Telecom Platform) Middleware for Erlang development Designed for fault tolerance and portability Behaviors: A formalization of design patterns Components Error handling, reporting and logging Mnesia, distributed real-time database management system CORBA, IDL Compiler, Java & C Interface Support HTTP Server + Client, FTP Client SNMP Agent + ASN.1 Compiler H.248 XML ...

Middleware for Erlang development

Designed for fault tolerance and portability

Behaviors: A formalization of design patterns

Components

Error handling, reporting and logging

Mnesia, distributed real-time database management system

CORBA, IDL Compiler, Java & C Interface Support

HTTP Server + Client, FTP Client

SNMP Agent + ASN.1 Compiler

H.248

XML

...

OTP Behaviors &quot;A formalization of design patterns&quot; A framework + generic code to solve a common problem Built-in support for debugging and software upgrade Makes it easier to reason about the behavior of a program Examples of OTP behaviors application defines how an application is implemented supervisor used to write fault-tolerant supervision trees gen_server for writing client-server applications gen_event for writing event handlers gen_fsm for finite state machine programming

&quot;A formalization of design patterns&quot;

A framework + generic code to solve a common problem

Built-in support for debugging and software upgrade

Makes it easier to reason about the behavior of a program

Examples of OTP behaviors

application defines how an application is implemented

supervisor used to write fault-tolerant supervision trees

gen_server for writing client-server applications

gen_event for writing event handlers

gen_fsm for finite state machine programming

Using Erlang as a Test Tool Language Declarative style Program for the correct case Pattern matching used for compact &quot;assertions&quot; EXIT indicates test case failure Easy to spawn worker threads to test concurrency patterns Test case cleanup is easy due to local variables, process linking and cascading EXITs

Declarative style

Program for the correct case

Pattern matching used for compact &quot;assertions&quot;

EXIT indicates test case failure

Easy to spawn worker threads to test concurrency patterns

Test case cleanup is easy due to local variables, process linking and cascading EXITs

Experiences from Erlang in Large Projects Easy to build a first runnable application Easy to debug Easy to maintain Very strong support for fault tolerance Suitable for large systems/projects Great for prototyping Impressive performance/scalability in real applications Outstanding tool for test automation High programmer satisfaction

Easy to build a first runnable application

Easy to debug

Easy to maintain

Very strong support for fault tolerance

Suitable for large systems/projects

Great for prototyping

Impressive performance/scalability in real applications

Outstanding tool for test automation

High programmer satisfaction

Erlang-based Products as of today Ericsson: AXD 301, GPRS, (NetSim), LCS Nortel: SSL Accelerator, SSL VPN gateway + others TMobile: IN applications Vail Systems: Computer Telephony Apps Service Prov. Erlang Financial Systems: Banking & Lottery systems Mobile Arts: Presence & Messaging for GSM/UMTS Synap.se: Billing & device configuration Blue Position: Bluetooth Location Information System Motivity: Answer Supervision Generator, Signalling Gateway Telia: CTI Platform Corelatus: Signalling gateways & cross-connects Bluetail/TeleNordia: Robust SMTP Mail Server Univ. of Coruña: VoD Cluster

Ericsson: AXD 301, GPRS, (NetSim), LCS

Nortel: SSL Accelerator, SSL VPN gateway + others

TMobile: IN applications

Vail Systems: Computer Telephony Apps Service Prov.

Erlang Financial Systems: Banking & Lottery systems

Mobile Arts: Presence & Messaging for GSM/UMTS

Synap.se: Billing & device configuration

Blue Position: Bluetooth Location Information System

Motivity: Answer Supervision Generator, Signalling Gateway

Telia: CTI Platform

Corelatus: Signalling gateways & cross-connects

Bluetail/TeleNordia: Robust SMTP Mail Server

Univ. of Coruña: VoD Cluster

Downloads since Open Source Launch ’98 Grouping: 6 months

Example Products: Outside Ericsson Amazon Web Services - SQS and SimpleDB, iMDB Facebook - social networking chat Powerset (now Microsoft bing) – Semantic Search & NLP Twitter – microbloging Slideaware.net – presentations Mochimedia – ads in Flash games Del.icio.us / Yahoo! – social bookmarking

Amazon Web Services - SQS and SimpleDB, iMDB

Facebook - social networking chat

Powerset (now Microsoft bing) – Semantic Search & NLP

Twitter – microbloging

Slideaware.net – presentations

Mochimedia – ads in Flash games

Del.icio.us / Yahoo! – social bookmarking

Example Products: Open Source EDDIE, Distributed TCP/IP based Clusterware Wings 3D, a 3D modeller based on Nendo YAWS, Yet Another Web Server RabbitMQ, high performance enterprise messaging Ejabberd, instant messaging server Erlyweb, web development framework

EDDIE, Distributed TCP/IP based Clusterware

Wings 3D, a 3D modeller based on Nendo

YAWS, Yet Another Web Server

RabbitMQ, high performance enterprise messaging

Ejabberd, instant messaging server

Erlyweb, web development framework

Example Products: Open Source Apache CouchDB – document-based DB with REST I/F Disco – Map/Reduce framework for Erlang Fuzed – Generic clustering framework (Powerset) Mochiweb – Fast lightweight web server framework (like Java Servlets for Erlang) Many-many web frameworks OpenPoker – scalable Poker server DHT – Distributed Key/Value Stores – 90% of all implementations in Erlang – Dunomite, Scalaris, etc.

Apache CouchDB – document-based DB with REST I/F

Disco – Map/Reduce framework for Erlang

Fuzed – Generic clustering framework (Powerset)

Mochiweb – Fast lightweight web server framework (like Java Servlets for Erlang)

Many-many web frameworks

OpenPoker – scalable Poker server

DHT – Distributed Key/Value Stores – 90% of all implementations in Erlang – Dunomite, Scalaris, etc.

Erlang good fit for: Irregular concurrency Task-level parallelism Fine-grained parallelism Network servers Distributed systems Middleware: Parallel databases Message Queue servers Soft Real-Time / Embedded applications Monitoring, control and testing tools

Irregular concurrency

Task-level parallelism

Fine-grained parallelism

Network servers

Distributed systems

Middleware:

Parallel databases

Message Queue servers

Soft Real-Time / Embedded applications

Monitoring, control and testing tools

Erlang not so good for: Concurrency more appropriate to synchronized parallel execution: Data Parallelism Floating-point intensive code (HPC) Text Processing / Unicode Traditional GUI Hard Real-Time applications Projects using: Non-portable instructions Running on JVM / CLR Extensive use of libraries in other languages

Concurrency more appropriate to synchronized parallel execution:

Data Parallelism

Floating-point intensive code (HPC)

Text Processing / Unicode

Traditional GUI

Hard Real-Time applications

Projects using:

Non-portable instructions

Running on JVM / CLR

Extensive use of libraries in other languages

Questions?