Erlang在多核处理器上的可扩展性研究

需积分: 9 23 浏览量更新于2024-07-18 收藏 1.9MB PDF 举报

"erlang on many core - MasterofScienceThesis - Stockholm, Sweden 2011 - TRITA-ICT-EX-2011:5 - Jianrong Zhang - Characterizing the Scalability of Erlang VM on Many-core Processors" 随着科技的进步，处理器核心的数量在单个晶片或封装内不断增加，我们正步入多核时代。多核处理器包含大量核心，通常认为拥有超过30个核心的处理器就属于多核范畴。多核处理器对效率提出了更高的要求，可能需要采用如片上网络等技术来连接芯片上的所有核心。 Erlang是一种针对这种发展趋势的语言，它通过消息传递和对并发编程的原生支持，为在多核系统上开发应用程序提供了便利。然而，应用程序的可扩展性在很大程度上取决于底层Erlang运行时系统或虚拟机（VM）的性能。Jianrong Zhang的硕士论文研究了Erlang VM在具有64个核心的TILEPro64多核处理器上的可扩展性，目的是研究并行Erlang VM的实现，分析其性能，识别瓶颈，并提供优化建议。为了达成目标，作者对VM进行了基准测试程序的测试，以发现潜在问题。这些问题随后通过更深入的元分析进行检查。通过这样的研究，可以更好地理解Erlang在多核环境下的表现，为未来优化Erlang VM的性能提供指导。这不仅对于Erlang语言的开发者和使用者具有重要意义，也对多核处理器上的软件开发策略有深远的影响。在多核处理器上，Erlang VM的扩展性是一个关键的考虑因素，因为不同的核心数量可能会影响程序的执行速度、资源利用率和并发处理能力。论文的结果可能会揭示Erlang VM在面对大量核心时的效率问题，以及如何通过改进VM的设计和优化来充分利用硬件资源。这些发现对于提升Erlang在大规模并行计算中的应用潜力至关重要。 "erlang on many core"这一主题探讨了Erlang在多核处理器环境下的性能和可扩展性，这对于理解和优化未来多核系统上的并发编程有着深远的理论和实践价值。通过深入研究Erlang VM的行为，我们可以期待更高效、更具可扩展性的并发解决方案，从而充分发挥多核处理器的潜力。

sive. Programs developed in Erlang are usually more concise than their counterparts

implemented in other traditional languages, such as C and C++, and it also takes less

time to develop [32]. Shorter time to market can be achieved. In addition, the resulting

code is more readable and maintainable.

While Erlang is productive, it is not a solution for all needs, and it is by no means

trivial to write correct and efﬁcient Erlang programs. It is not suitable for some applica-

tion domains, such as number-crunching applications and graphics-intensive systems.

Ordinary Erlang applications are compiled to bytecode and then interpreted or executed

by the virtual machine which is also called emulator. Bytecode is an intermediate repre-

sentation of a program. It can be considered that the source code is compiled according

to an intermediate instruction set

that is implemented by the virtual machine and dif-

ferent from the one implemented by the underlying real processor. The bytecode is

translated into the instructions that can be run on the real machine by the emulator.

Because of this extra translation step, applications running on a VM are usually slower

than their counterparts that are directly compiled into machine code. If more speed

is required, Erlang applications can be compiled into native machine code with HiPE

(High Performance Erlang System) compiler [21][22][35]. But if an application is

time critical and compute-intensive, and its execution time should be reduced as much

as possible, such as some scientiﬁc programs, Erlang is not always a good choice [10]

and a fast low-level language may be better. In one word, Erlang should be used in the

right place.

2.1.2 Erlang Features

In general, Erlang has the following features

• Concurrency - A separate task, or piece of work, can be encapsulated into an Er-

lang process. It is fast to create, suspend or terminate an Erlang process. Erlang

process is much more light-weight than OS process

or thread

. An Erlang sys-

tem may have hundreds of thousands of or even millions of concurrent processes.

A process’ memory area can vary dynamically according to requirements. Each

process has a separate memory area, and there is no shared memory. As a result,

a process cannot corrupt another process’ memory. Asynchronous message pass-

ing is the only way of inter-process communication provided by the language.

Message sending is non-blocking. A process continues execution after sending

a message. A process waiting for a message is suspended if there is no matching

message in its mailbox, or message queue, and will be informed when a new

message comes.

• Robustness - Erlang supports a catch/throw-style exception detection and recov-

ery mechanism. A process can also register to receive a notiﬁcation message

if another process terminates even it is executing on a different machine in a

The set of instructions implemented by a processor

http://www.erlang.org/white_paper.html

A process is an instance of a program that is being executed.

A thread is a part of a process that can be executed concurrently and scheduled by operating system

separately.

network. With this feature, processes can be supervised by others. If a process

crashes, it can be restarted by its supervisor.

• Hot code replacement - Due to the high availability requirement of a telecom

system, It cannot be halted when upgrading. Erlang provides a way of replac-

ing running code without stopping the system. The runtime system maintains a

global table containing the addresses for all the loaded modules. The addresses

are updated when new modules replace old ones. Future calls invoke functions

in the new modules. The old code is phased out. Two versions of a module can

run simultaneously in a system.

• Distribution - Erlang applications can be executed in a distributed environment.

An instance of Erlang virtual machine is called a node. Multiple nodes can be

run on one machine or several machines which may have different hardware

architectures or operating systems. Processes can be spawned to nodes on other

machines, and messages can be passed between different nodes exactly as on one

node.

• Soft real-time - Erlang supports developing soft real-time applications with re-

sponse time demands in the order of milliseconds.

• Memory management - Memory is managed by the virtual machine automat-

ically. It is not allocated and deallocated explicitly by a programmer. Every

process’ memory area is garbage collected

separately. When a process termi-

nates, its memory is simply reclaimed. This results in a short garbage collection

time and less disturbance to the whole system. Also a better real-time property

can be achieved. If the memory of all processes is garbage collected at the same

time, without a sophisticated memory collector that can do incremental garbage

collection [36] the system will be stopped for a long time.

In addition to the above main features, Erlang is a dynamically typed language. There

is no need to declare variables before they are used. A variable is bound to a value when

it ﬁrst occurs, and the value cannot be changed later, which is called single assignment.

All variables are local to the functions in which they are bound. Global variables don’t

exist. There is an exception that data associated with a key can be stored in the process

dictionary and retrievedin the life time of that process before they are erased. It behaves

like a global variable. The value associated with a key can also be changed. Using the

process dictionary is not encouraged, since the resulting program is hard to debug and

maintain. Erlang provides some way of sharing data, such as the ETS (Erlang Term

Storage) table [15] and the Mnesia database [31].

Erlang’s basic data types are number, atom, function type, binary, reference, pro-

cess identiﬁer, and port identiﬁer. Numbers include integers and ﬂoats. An integer can

be arbitrarily large. A large number that doesn’t ﬁt into a word is represented with arbi-

trary number of words, which is called bignum. The precision of a ﬂoating-point value

is the same as that of a 64-bit double precision number deﬁned in the IEEE 754–1985

Garbage collection is to reclaim the memory occupied by data objects that are no long in use. It may

compact the remaining data by moving them closer.

standard. Atoms are constant literals. It is like enumeration types in other languages.

In the Erlang VM there is a global table storing actual values or literals of all the atoms

used in the system, and atoms are indices to the table in fact. There is no separate

Boolean type. Instead, the atoms true and false are used with Boolean operators. Since

Erlang is a functional programming language, a function can be considered as a type of

data. Functions can be passed as arguments to other functions, or can be results of other

functions. They also can be stored in composite data structures such as tuples and lists,

or sent in messages. A binary is a reference to a chunk of raw, untyped memory, or a

stream of ones or zeros. It is an efﬁcient way of storing or transferring large amounts of

data. Because other data types are heavily tagged [2][33], which means in the internal

representations there are extra tags indicating the types of data objects. For example,

each integer has a tag. With binary, less tag overhead is introduced. A binary can be

manipulated on bit level. It’s a good way to implement messages or packets of com-

munication protocols like HTTP. References are unique values generated on a node,

and can be used to label and identify messages. Process and port identiﬁers represent

different processes and ports.

Erlang ports are used to pass binary messages between Erlang nodes and external

programs which may be written in other programming languages, such as C and Java.

An external program runs in a separate OS process, and is connected to a port via

pipes

on Linux. In an Erlang node, a port behaves like a process. For each port, there

is an Erlang process, named connected process, responsible for coordinating all the

messages passing through that port.

Erlang’s composite data types are tuples, lists and records. Tuples and lists are

used to store a collection of items. Items are data values that can be of any valid Erlang

types. The difference between tuples and lists is that they are processed differently. We

can only extract particular elements from a tuple. But lists can be split and combined.

Especially, a non-empty list can be broken into a head, the ﬁrst element in the list, and

a tail, a list that contains all the remaining items. Characters and strings are not formal

data types in Erlang. They are represented by integers and lists of integers respectively.

Record is similar to structure in C programming language. It is a data structure with a

ﬁxed number of ﬁelds. Fields have names and can be accessed by their names, while

in tuples, ﬁelds (items) are accessed by positions.

Erlang programs consist of modules, each of which contains a number of related

functions. Functions can be called from other modules if they are explicitly exported.

A function can include several clauses, and a clause is chosen to execute at runtime

by pattern matching according to the argument passed. Erlang doesn’t provide loop

constructs, so that loops are built with recursive function calls. To reduce stack con-

sumption, tail call optimization is implemented. A new stack frame is not allocated

when the last statement of a function is a call to itself.

The Erlang language is concise, but it has a large set of built-in functions (BIFs).

In particular, the OTP middleware provides a library of standard solutions for building

telecommunication applications, such as a real-time database, servers, state machines,

and communication protocols.

Pipe is used to communicate with a process by reading from or writing to associated ﬁle descriptors.

2.1.3 Erlang’s Concurrency primitives

Spawn, “!” (send), and receive are Erlang’s primitives for concurrent programming.

These primitives allow a process to spawn new processes, and communicate with other

processes through asynchronous message passing. When spawning a process, node

name, module name, function name, and arguments to the function are passed to the

built-in function spawn(). A process identiﬁer is returned if the spawning is successful.

Messages are sent with the Pid ! Message construct, in which Pid is a process identiﬁer,

and Message is a value of any valid Erlang data type. The receive statement is used to

retrieve a message from a process’ message queue, which has the following form:

r e ce i v e

P a t te r n 1 when Guard1 −> e x p r e s s i o n s 1 ;

P a t te r n 2 when Guard2 −> e x p r e s s i o n s 2 ;

Other −> e x p r e s si o n s o t he r

a f t e r % o p ti o na l c lau se

Timeout −> ex p r e s sion stimeou t

end

In the statement, after clause (timeout mechanism), other clause and guards are op-

tional. When a receive statement of a process is executed, the VM checks each message

in the message queue of the process to see whether it is matching one of the patterns.

The patterns are matched sequentially. If a pattern is matching and the corresponding

guard, which is a test, succeeds, the expressions follow that pattern are evaluated, and

the following patterns are not matched any more. When there is no message in the

queue or no matching message, the process is suspended and scheduled out. A sus-

pended process waiting for a message becomes runnable if it receives a new message,

and is appended to the run queue of the scheduler which the process is associated with.

Then when the process is selected to execute, the new message is matched to the pat-

terns in the receive statement again. It is possible that the new message doesn’t match

any patterns, and the process is suspended once more. Sometimes, the last pattern other

is set to match all messages, and if a message doesn’t match any previous patterns, the

expressions following the last pattern will be executed and the message is removed

from the message queue.

When there is an after clause and the process is suspended waiting for a message, it

will be woken up after Timeout milliseconds if it doesn’t receive a matching message

during that time and then the corresponding expressions are executed.

2.2 TILEPro64 Processor

Figure 2.1 is the block diagram of TILEPro64 processor. A TILEPro64 CPU integrates

64 identical processor cores or tiles interconnected by Tilera’s iMesh on-chip networks.

There are six independent networks for different purposes. It also integrates memory

and some I/O controllers. Each tile is a complete processor with L1 (Level 1), L2

caches and a switch connecting the tile to the 8X8 meshes, as shown in Figure 2.2. A

full operating system can run on each tile independently. In this project, we run a single

剩余85页未读，继续阅读

tangcunren

粉丝: 0
资源: 2

Erlang在多核处理器上的可扩展性研究

erlang编程 Introducing Erlang

erlang25.0 windows版本

ubuntu20.04 安装erlang

erlang>=25.0

linux 离线卸载erlang

erlang 21.3.rpm

erlang环境变量配置

centos7 erlang版本升级

erlang安装时报错

erlang25.3.2

最新资源