4 Distributed Erlang ProgramsErlang

4 Distributed Erlang Programs
Erlang applications are often designed to run on distributed networks of processors. We use the term node to mean a complete self-contained Erlang system. In a distributed network one or more Erlang nodes may run on a signal computer.

In designing the language we were careful to avoid any primitives which would not map naturally onto a distributed model of computation. The only way of exchanging data between process is by message passing. All the primitives involving processes work transparently on a network of Erlang nodes.

Inter-processor communication makes use of a sophisticated caching technique [WIK94] which makes data transfer highly efficient. Indeed a cross-processor remote procedure call in Erlang is often more efficient than in a language such as C.

Recall that the primitive spawn creates a new parallel process. The new process is always creates on the current node. To create a parallel process on a different node the primitive Pid=spawn(N,Mod....) is used.

This creates a new parallel process on the Erlang node. This allows an Erlang process running on one Erlang node to create a parallel process on another node in the system. All operations on the new process behave in exactly the same way as if the process had beed created on the local node.

Recall that that register primitive created a global alias for a process identifier, the scope of this alias is the node on which the process was registered, so this name is not visible outside the node.

To send a message to a registered process on a different node the syntax {}! Msg is used. This sends Msg to the process named Atom on node.

To turn the bank client-server model from a single processor solution to a fully distributed program we made a single line change to the code in the bank_cilent module, changing the line.

where Host@Domain is the name of the node where the bank server is running.
Note that no data transfer languages are needed to describe the structure of the message which are sent between the different system. The set of messages to be sent does not need to be known in advance but is encoded at run-time. Problems of confusion between different byte orderings on different machines and different representations of data structures in memory are eliminated.

5. Error Handling in Erlang
Erlang has three different mechanism for trapping run-time errors, these can be used to:
-Monitor the evaluation of an expression
-monitor the behavior of a process
-raise an exception when an undefined function is called.

Suppose we evaluate N/M where M is equal to zero, this will cause a run-time error and the process in which this evaluation is performed will die.
We can detect this error in one of two ways. The first method makes use of the primitives catch and throw which are used for monitoring the evaluation of an expression.
The expression x=catch N/M evaluates to the tuple {} where what is an error descriptor in this case term:


catch can be though of as a meta-function which changes the normal evaluation model by converting errors into term which can be manipulated by the program.
If no error occurs then the result of evaluating catch Expr is the same as that of evaluating Expr.

The primitive throw (Expr) evaluates Expr which then becomes the return value of any enclosing catch.
Using catch and throw programs can be written to monitor and correct local errors within a process.
The second error handling mechanisms determines what happens when a process dies. Suppose some code evaluating in a process generates an error and that this error is not handled using the catch mechanism described above.
If the process Pid1 evaluates the expression link(Pid2) then a link is established between these two processes.
When any process dies it broadcasts a message containing information about why it died to all processes in the system to which it is linked. Thus if Pid1 dies, a message containing the reason for death is sent to the process Pid2. link is symmetric, so if Pid2 dies an error message will be sent to Pid1.

As an example, the function monitor( ) creates tow parallel processors. One of these processes evaluates the expression M:F(Args) the other monitors the process performing the evaluation dies, a new process is created by the monitoring process.

**

The primitive process_flag(trap_exist, true) allows the evaluating process to trap exit messages. spawn_link creates a new parallel process and links to it an atomic action.
The third error handling mechanism is used to trap errors occurring when undefined functions are called. If an attempt is made to evaluate M:F(Arge) and no code for the module M has been loaded into the system then the function undefined_function(M,F,Args) in the module error_handler is called

**

The point to note here is not this particular code but rather the fact that the user can program exactly what happens when a program tries to execute code that has not been loaded into the system.

Different types of system, for example, embedded systems, or, development systems need different types of code loading strategy. This above mechanism allows code loading strategies to be programmed by the user in Erlang itself.

ผลลัพธ์ (ไทย) 1:

4 โปรแกรมเออร์แลง
กระจายการใช้งานเออร์แลงมักจะได้รับการออกแบบให้ทำงานบนเครือข่ายการกระจายการประมวลผล เราใช้โหนดระยะหมายถึงระบบสมบูรณ์เออร์แลงที่ตนเองมี ในเครือข่ายการกระจายหนึ่งหรือมากกว่าหนึ่งโหนด Erlang อาจเรียกใช้บนคอมพิวเตอร์สัญญาณ.

ในการออกแบบภาษาเราก็ระมัดระวังเพื่อหลีกเลี่ยงวิทยาการใด ๆ ซึ่งจะไม่ map ธรรมชาติบนรูปแบบการกระจายของการคำนวณ วิธีเดียวของการแลกเปลี่ยนข้อมูลระหว่างกระบวนการโดยผ่านข้อความ ทั้งหมดวิทยาการที่เกี่ยวข้องกับกระบวนการทำงานโปร่งใสในเครือข่ายของโหนด erlang.

การสื่อสารระหว่างหน่วยประมวลผลที่ทำให้การใช้เทคนิคการใช้แคชที่มีความซับซ้อน [wik94] ซึ่งทำให้การถ่ายโอนข้อมูลที่มีประสิทธิภาพสูง แน่นอนการเรียกขั้นตอนข้ามหน่วยประมวลผลระยะไกลในเออร์แลงมักจะมีประสิทธิภาพมากขึ้นกว่าในภาษาเช่น C.

เรียกว่าวางไข่ดั้งเดิมสร้างกระบวนการคู่ขนานใหม่ กระบวนการใหม่อยู่เสมอเมื่อสร้างโหนดปัจจุบันเพื่อสร้างกระบวนการคู่ขนานในโหนดที่แตกต่างกัน pid = ดั้งเดิมวางไข่ (n, Mod .... ) ถูกนำมาใช้.

นี้จะสร้างกระบวนการคู่ขนานใหม่บนโหนดเออร์แลง นี้จะช่วยให้ขั้นตอนการเออร์แลงทำงานบนโหนดเออร์แลงหนึ่งในการสร้างกระบวนการคู่ขนานกับโหนดอื่นในระบบ การดำเนินการทั้งหมดเกี่ยวกับกระบวนการใหม่ประพฤติในทางตรงเช่นเดียวกับถ้ากระบวนการ Beed ได้ถูกสร้างขึ้นในโหนดท้องถิ่น.

จำได้ว่าที่ลงทะเบียนดั้งเดิมถูกสร้างขึ้นนามแฝงทั่วโลกสำหรับขั้นตอนการระบุขอบเขตของนามแฝงนี้เป็นโหนดซึ่งการเข้าจดทะเบียนดังนั้นชื่อนี้ไม่สามารถมองเห็นด้านนอกโหนด.

ที่จะส่งข้อความไปยังขั้นตอนการลงทะเบียนของ โหนดที่แตกต่างกันไวยากรณ์ {}! ผงชูรสถูกนำมาใช้ นี้จะส่ง msg กับกระบวนการตั้งชื่ออะตอมในโหนด.

เพื่อเปิดธนาคารแบบไคลเอนต์เซิร์ฟเวอร์จากโซลูชั่นประมวลผลเดียวกับโปรแกรมการกระจายอย่างเต็มที่เราทำเปลี่ยนแปลงเส้นเดียวกับรหัสในโมดูล bank_cilent เปลี่ยนสาย.

ที่ @ host โดเมนเป็นชื่อของโหนดที่ เซิร์ฟเวอร์กำลังทำงานอยู่ธนาคาร.
หมายเหตุว่าไม่มีภาษาการถ่ายโอนข้อมูลที่จำเป็นในการอธิบายโครงสร้างของข้อความที่ถูกส่งระหว่างระบบที่แตกต่างกันชุดของข้อความที่จะส่งไม่จำเป็นต้องเป็นที่รู้จักล่วงหน้า แต่จะถูกเข้ารหัสที่ใช้เวลา ปัญหาของความสับสนระหว่าง orderings ไบต์ที่แตกต่างกันในเครื่องที่แตกต่างกันและการแสดงที่แตกต่างกันของโครงสร้างข้อมูลในหน่วยความจำจะถูกตัดออก.

5 จัดการข้อผิดพลาดในเออร์แลงเออร์แลง
มีสามกลไกที่แตกต่างกันสำหรับการวางกับดักเวลาทำงานผิดพลาดเหล่านี้สามารถนำไปใช้:
การประเมินผลการติดตามตัวของการแสดงออก
ตรวจสอบพฤติกรรมของกระบวนการ
เพิ่มการยกเว้นเมื่อฟังก์ชั่นที่ไม่ได้กำหนดจะเรียกว่า.

สมมติว่าเราประเมิน n / m เมื่อ m มีค่าเท่ากับศูนย์นี้จะทำให้เวลาทำงานผิดพลาด และกระบวนการในการประเมินผลที่จะดำเนินการนี​​้จะตาย.
เราสามารถตรวจสอบข้อผิดพลาดนี้ในหนึ่งในสองวิธีวิธีแรกที่ทำให้การใช้พื้นฐานของการจับและโยนซึ่งจะใช้สำหรับการตรวจสอบการประเมินผลของการแสดงออก
แสดงออก x = จับ n / m ประเมิน tuple {} ซึ่งเป็นสิ่งที่บ่งชี้ข้อผิดพลาดในระยะกรณีนี้:.


จับได้ว่าเป็นเมตาฟังก์ชั่นซึ่งการเปลี่ยนแปลงรูปแบบการประเมินตามปกติข้อผิดพลาดแปลงเป็นระยะที่สามารถจัดการได้โดยโปรแกรม.
ถ้าไม่มีข้อผิดพลาดเกิดขึ้นแล้วผลของการประเมิน expr จับเป็นเช่นเดียวกับที่ของการประเมิน expr.

โยนดั้งเดิม (expr) ประเมิน expr ซึ่งก็จะกลายเป็นค่าตอบแทนจากการปิดล้อมจับใด ๆ .
ใช้จับและโยนโปรแกรมที่สามารถเขียนได้ เพื่อตรวจสอบและแก้ไขข้อผิดพลาดท้องถิ่นภายในกระบวนการ.
ข้อผิดพลาดที่สองการจัดการกลไกการกำหนดสิ่งที่เกิดขึ้นเมื่อกระบวนการตายสมมุติว่ารหัสการประเมินในขั้นตอนบางอย่างสร้างข้อผิดพลาดและข้อผิดพลาดนี้ไม่ได้รับการจัดการโดยใช้กลไกการจับที่อธิบายข้างต้น.
ถ้า pid1 กระบวนการประเมินการเชื่อมโยงการแสดงออก (pid2) แล้วการเชื่อมโยงที่จะจัดตั้งขึ้นระหว่างทั้งสองกระบวนการ.
เมื่อกระบวนการใด ๆ ตายมันเป็นกระบอกเสียงที่มีข้อความที่มีข้อมูลเกี่ยวกับว่าทำไมมันตายไปยังกระบวนการทั้งหมดในระบบที่มีการเชื่อมโยงดังนั้นหาก pid1 ตายข้อความที่มีเหตุผลสำหรับการตายจะถูกส่งไป pid2 กระบวนการ การเชื่อมโยงเป็นสมมาตรดังนั้นหาก pid2 ตายข้อความข้อผิดพลาดจะถูกส่งไป pid1.

เป็นตัวอย่างการตรวจสอบฟังก์ชัน () สร้างหน่วยประมวลผลแบบขนานพ่วง หนึ่งในกระบวนการเหล่านี้ประเมินการแสดงออก m: f (args) จอภาพอื่น ๆ ขั้นตอนการดำเนินการประเมินผลการตายกระบวนการใหม่ถูกสร้างขึ้นโดยกระบวนการตรวจสอบ.

**

process_flag ดั้งเดิม (trap_exist จริง) ช่วยให้ขั้นตอนการประเมินผลจะวางกับดักข้อความออก spawn_link สร้างกระบวนการคู่ขนานใหม่และการเชื่อมโยงไปยังการกระทำของอะตอม.
ข้อผิดพลาดที่สามกลไกการจัดการที่ใช้ในการดักจับข้อผิดพลาดที่เกิดขึ้นเมื่อไม่ได้กำหนดฟังก์ชั่นที่เรียกว่า ถ้าความพยายามที่จะทำเพื่อประเมินเมตร:f (ARGE) และรหัสสำหรับโมดูลเมตรไม่ได้รับการโหลดลงในระบบแล้ว undefined_function ฟังก์ชัน (m, F, args) ใน error_handler โมดูลที่เรียกว่า

**

ชี้ไปที่ทราบที่นี่ไม่ได้เป็นรหัสนี้โดยเฉพาะอย่างยิ่ง แต่ความจริงที่ว่าผู้ใช้สามารถตั้งโปรแกรมให้ตรงกับสิ่งที่เกิดขึ้นเมื่อโปรแกรมพยายามที่จะรันโค้ดที่ไม่ได้รับการโหลดเข้าสู่ระบบ.

ประเภทที่แตกต่างกันของระบบตัวอย่างเช่น,ระบบฝังตัวหรือการพัฒนาระบบจำเป็นต้องมีประเภทที่แตกต่างกันของกลยุทธ์การโหลดรหัส กลไกดังกล่าวนี้ช่วยให้กลยุทธ์การโหลดรหัสที่จะถูกโปรแกรมโดยผู้ใช้ในการเออร์แลงตัวเอง.

ผลลัพธ์ (ไทย) 2:

โปรแกรม Erlang กระจาย 4
Erlang โปรแกรมประยุกต์มักจะได้รับการออกแบบให้ทำงานบนเครือข่ายแบบกระจายตัวประมวลผล เราใช้โหนระยะหมายถึง ระบบ Erlang สมบูรณ์อยู่ในตัวเอง ในเครือข่ายแบบกระจาย อย่าง น้อยหนึ่งโหน Erlang อาจเรียกใช้บนคอมพิวเตอร์สัญญาณได้

ในการออกแบบภาษา เราได้ระมัดระวังในการนำที่จะแม็ปธรรมชาติลงแบบกระจายการคำนวณไม่ หลีกเลี่ยง เป็นวิธีเดียวของการแลกเปลี่ยนข้อมูลระหว่างกระบวนการ ด้วยข้อความผ่าน นำทั้งหมดที่เกี่ยวข้องกับกระบวนการทำงานโปร่งใสบนเครือข่ายของ Erlang โหน

สื่อสารระหว่างตัวประมวลผลทำให้ใช้ซับซ้อนแคเทคนิค [WIK94] ซึ่งทำให้การถ่ายโอนข้อมูลมีประสิทธิภาพสูงขึ้น แน่นอนการเรียกขั้นตอนระยะไกลระหว่างตัวประมวลผลในภาษาเออร์แลงอยู่มักจะมีประสิทธิภาพมากกว่าในภาษาเช่น C.

นึกว่า วางไข่ดั้งเดิมสร้างกระบวนการคู่ขนานใหม่ กระบวนการใหม่นี้จะสร้างบนโหนดปัจจุบัน เพื่อสร้างกระบวนการแบบขนานบนโหนดอื่น Pid=spawn(N,Mod...) ดั้งเดิมใช้

นี้สร้างกระบวนการคู่ขนานใหม่บนโหน Erlang นี้ช่วยให้กระบวนการภาษาเออร์แลงทำงานบนโหน Erlang เพื่อสร้างกระบวนการแบบขนานบนโหนอื่นในระบบ ดำเนินการใหม่ทั้งหมดทำงานในแบบเดียวว่า beed ที่สร้างบนโหนดภายในมีกระบวนการ

นึกว่า ทะเบียนดั้งเดิมสร้างนามแฝงสากลสำหรับรหัสกระบวนการ ขอบเขตของนามแฝงนี้ว่าโหนที่กระบวนการได้ลงทะเบียนไว้ ดังนั้นชื่อนี้เห็นนอกโหน

ส่งข้อความถึงกระบวนการลงทะเบียนบนโหนดอื่น{}ไวยากรณ์ มีใช้ผงชูรส นี้ส่งข่าวสารเกี่ยวกับกระบวนการชื่ออะตอมบนโหน

เปิดใช้งานรุ่นไคลเอ็นต์-เซิร์ฟเวอร์ธนาคารจากโซลูชันตัวประมวลผลเดียวกับโปรแกรมกระจายเต็มเราทำบรรทัดเดียวเปลี่ยนเป็นรหัสในโมดู bank_cilent เปลี่ยนบรรทัด

ชื่อของโหนเซิร์ฟเวอร์ธนาคารทำงาน Host@Domain
หมายเหตุว่า ไม่มีข้อมูลถ่ายโอนภาษาจำเป็นต้องอธิบายโครงสร้างของข้อความที่ถูกส่งระหว่างระบบแตกต่างกัน ชุดของข้อความจะถูกส่งไม่จำเป็นต้องทราบล่วงหน้า แต่ถูกเข้ารหัสในเวลาเรียกใช้ เป็นตัดปัญหาความสับสนระหว่าง orderings ไบต์ต่าง ๆ ในเครื่องจักรต่าง ๆ และอื่นที่ใช้แทนโครงสร้างข้อมูลในหน่วยความจำ

5 ข้อผิดพลาดในการจัดการใน Erlang
ภาษาเออร์แลงมีสามต่างกลไกการดักจับข้อผิดพลาดรันไทม์ สิ่งเหล่านี้สามารถใช้:
-ตรวจสอบการประเมินนิพจน์
-ตรวจสอบลักษณะการทำงานของกระบวนการ
-เพิ่มข้อยกเว้นเมื่อเรียกฟังก์ชันที่ไม่ได้

สมมติว่าเราประเมิน N/M ที่ M มีค่าเท่ากับศูนย์ นี้จะทำให้มีข้อผิดพลาดขณะทำงาน และดำเนินการกระบวนการประเมินนี้จะตายจะได้
เราสามารถตรวจหาข้อผิดพลาดนี้ในสองวิธีการ วิธีแรกให้ใช้นำจับ และโยนซึ่งใช้สำหรับการติดตามประเมินผลของการนิพจน์
x จับ = N/M นิพจน์การ{}ในทูเพิลซึ่งเป็นการบอกข้อผิดพลาดในกรณีนี้ระยะ:


จับได้ว่าของเป็น meta-ฟังก์ชัน ที่เปลี่ยนแปลงแบบปกติประเมินผล โดยการแปลงข้อผิดพลาดในระยะที่สามารถถูกจัดการ โดยโปรแกรมได้
ถ้าไม่เกิดข้อผิดพลาด แล้วจับผลประเมิน Expr เป็นเหมือนกับที่ประเมิน Expr

โยนดั้งเดิม (Expr) ประเมิน Expr ซึ่งเป็นค่าที่ส่งคืนของการล้อมจับแล้ว
ใช้จับ และสามารถเขียนโปรแกรมโยนเพื่อตรวจสอบ และแก้ไขข้อผิดพลาดภายในกระบวนการ
ข้อผิดพลาดที่สองจัดการกลไกกำหนดเกิดอะไรขึ้นเมื่อกระบวนการตาย สมมติว่าประเมินบางรหัสในกระบวนการสร้างข้อผิดพลาด และข้อผิดพลาดนี้จะจัดการโดยใช้กลไกตามที่อธิบายข้างต้นไม่
Pid1 กระบวนการประเมิน link(Pid2) นิพจน์ ถ้าสร้างขึ้นระหว่างเหล่านี้สองกระบวนการเชื่อมโยง
เมื่อกระบวนการใดตายมันถ่ายทอดข้อความที่ประกอบด้วยข้อมูลเกี่ยวกับทำไมมันตายไปกระบวนการทั้งหมดในระบบซึ่งเป็นการเชื่อมโยง ดังนั้นถ้า Pid1 ตาย ข้อความที่ประกอบด้วยเหตุผลสำหรับความตายถูกส่งไปยังกระบวนการ Pid2 เชื่อมโยงเป็นสมมาตร ดังนั้นถ้าตาย Pid2 จะส่งข้อความข้อผิดพลาดการ Pid1

เป็นตัวอย่าง, ()ตรวจสอบฟังก์ชันสร้างใยตัวประมวลผลแบบขนาน กระบวนการเหล่านี้อย่างใดอย่างหนึ่งประเมินนิพจน์ M:F(Args) จออื่น ๆ กระบวนการการประเมินตาย สร้างกระบวนการใหม่ โดยการตรวจสอบ

**

process_flag ดั้งเดิม (trap_exist จริง) ช่วยให้กระบวนการ evaluating กับดักข้อความออก spawn_link สร้างกระบวนการใหม่คู่ขนานและเชื่อมโยงไปอะตอมดำเนินการ
จัดการกลไกข้อผิดพลาดที่สามที่ใช้ในการดักข้อผิดพลาดเกิดขึ้นเมื่อยังไม่ได้กำหนดเรียกว่าฟังก์ชัน ถ้ามีความพยายามที่จะประเมิน m:F(Arge) และไม่มีรหัสสำหรับโม M ได้ถูกโหลดเข้าสู่ระบบแล้ว undefined_function(M,F,Args) ฟังก์ชันใน error_handler โมดูลคือ

**

จุดโปรดทราบนี่ไม่ใช่รหัสนี้เฉพาะแต่ค่อนข้างจริงให้ผู้ใช้สามารถโปรแกรมว่าอะไรเกิดขึ้นเมื่อโปรแกรมพยายามที่จะเรียกใช้รหัสที่ไม่ได้โหลดเข้าระบบ

ชนิดต่าง ๆ ของระบบตัวอย่าง ระบบฝังตัว หรือ พัฒนาระบบต้องรหัสโหลดกลยุทธ์ประเภทต่าง ๆ เหนือกลไกให้รหัสโหลดกลยุทธ์การตั้งโปรแกรม โดยผู้ใช้ในภาษาเออร์แลงเอง

ผลลัพธ์ (ไทย) 3:

4 Erlang เสร็จสิ้นแล้วหรือไม่โปรแกรมแอพพลิเคชัน
Erlang เสร็จสิ้นแล้วหรือไม่แม้ได้รับการออกแบบเพื่อใช้งานบนเครือข่ายการกระจายของโปรเซสเซอร์บ่อยครั้ง เราใช้โหนดระยะสั้นที่หมายถึงระบบ Erlang เสร็จสิ้นแล้วหรือไม่แบบบริการตัวเองที่สมบรูณ์แบบ ในเครือข่ายการกระจายโหนดหนึ่งหรือมากกว่า Erlang เสร็จสิ้นแล้วหรือไม่อาจใช้งานได้บนคอมพิวเตอร์สัญญาณ.

ในการออกแบบ ภาษา ที่เราได้ใช้ความระมัดระวังในการป้องกันไม่ให้ชนิดมูลฐานใดที่จะไม่เป็นธรรมชาติบนแผนที่รุ่นการกระจายมารวมกัน วิธีเดียวที่มีการแลกเปลี่ยนข้อมูลระหว่างกระบวนการคือโดยผ่านข้อความ ชนิดมูลฐานที่เกี่ยวข้องกับกระบวนการทำงานโปร่งใสบนเครือข่ายของโหนด Erlang เสร็จสิ้นแล้วหรือไม่.

การสื่อสารระหว่างโปรเซสเซอร์ทำให้การใช้เทคนิคการแคชที่[ wik : ABS 94 ]ซึ่งทำให้การถ่ายโอนข้อมูลได้อย่างมี ประสิทธิภาพ จริงๆแล้วการโทรตามขั้นตอนรีโมทคอนโทรลแบบโปรเซสเซอร์ที่ใน Erlang เสร็จสิ้นแล้วหรือไม่เป็นมี ประสิทธิภาพ มากกว่าใน ภาษา ใด ภาษา หนึ่งเช่น C

เรียกคืนที่ก่อหวอดสร้างกระบวนการคู่ขนานใหม่ กระบวนการใหม่อยู่เสมอจะสร้างกับโหนดในปัจจุบันในการสร้างกระบวนการคู่ขนานกับโหนดที่แตกต่างกันที่โพรเซส=ก่อหวอด( N ,ความทันสมัยใคร่รู้ได้....)มีการใช้

นี้จะสร้างกระบวนการแบบคู่ขนานใหม่ในโหนดที่ Erlang เสร็จสิ้นแล้วหรือไม่ โรงแรมแห่งนี้ช่วยให้กระบวนการ Erlang เสร็จสิ้นแล้วหรือไม่ซึ่งทำงานบนหนึ่งโหนด Erlang เสร็จสิ้นแล้วหรือไม่ในการสร้างกระบวนการทำงานแบบคู่ขนานบนโหนดหนึ่งในระบบ การดำเนินการทั้งหมดในกระบวนการใหม่ที่ทำตัวได้ด้วยวิธีเดียวกันว่ากระบวนการที่ได้สร้างขึ้นในห้องพักมีความโหนดในท้องถิ่น.

การเรียกคืน ผลิตภัณฑ์ ที่ลงทะเบียนสร้างชื่อระดับโลกที่ตัวระบุขั้นตอนที่ง่ายขอบเขตที่ของชื่อนี้เป็นโหนดที่กระบวนการที่ได้จดทะเบียนดังนั้นชื่อนี้ไม่สามารถมองเห็นได้จากด้านนอกโหนดที่.

ในการส่งข้อความที่จะดำเนินการจดทะเบียนกับโหนดที่แตกต่างไวยากรณ์{} ผงชูรสคือนำมาใช้ โรงแรมแห่งนี้จะส่งข้อความไปยังขั้นตอนที่มีชื่อว่าอะตอมบนโหนด.

ในการนี้ธนาคารเครื่องลูกข่าย - รุ่นเซิร์ฟเวอร์จากโปรเซสเซอร์ตัวเดียวโซลูชันเพื่อการกระจายโปรแกรมเราจะทำให้ที่บรรทัดเดียวเปลี่ยนเป็นรหัสในที่ bank_cilent โมดูลการเปลี่ยนสาย.

ที่โฮสต์@โดเมนคือชื่อของโหนดที่ธนาคารเซิร์ฟเวอร์กำลังทำงานอยู่.
บันทึกไว้ด้วยว่าไม่มีการถ่ายโอนข้อมูล ภาษา จะต้องอธิบายถึงโครงสร้างของข้อความที่จะถูกส่งไประหว่างที่แตกต่างกันระบบ.ตั้งค่าของข้อความที่จะถูกส่งไปไม่จำเป็นต้องเป็นที่รู้จักกันในชื่อเป็นการล่วงหน้าแต่จะถูกทำการเข้ารหัสที่ใช้งาน - เวลา ปัญหาของความสับสนระหว่างการสั่งซื้อ byte แตกต่างกันในเครื่องอื่นและการรับรองที่แตกต่างของโครงสร้างข้อมูลในหน่วยความจำจะถูกทำลาย.

5 เกิดข้อผิดพลาดในการจัดการ Erlang เสร็จสิ้นแล้วหรือไม่ตอบแทน
สาม Erlang เสร็จสิ้นแล้วหรือไม่มีกลไกการจับตัวของข้อผิดพลาดที่แตกต่างสำหรับเวลาใช้งานเหล่านี้สามารถใช้ในการ:
- มอนิเตอร์การประเมินผลของการแสดงออกที่
- ติดตามพฤติกรรมของกระบวนการ
ซึ่งจะช่วย - ยกยกเว้นเมื่อใช้งานไม่ได้กำหนดที่จะถูกเรียกว่า.

คิดว่าเราประเมิน N / M ที่ม.มีเท่ากับศูนย์แห่งนี้จะทำให้เกิดข้อผิดพลาดเรียกใช้ - เวลาและกระบวนการในการประเมินผลซึ่งจะมีการดำเนินการนี้จะตาย.
จะสามารถตรวจพบข้อผิดพลาดนี้ในหนึ่งในสองวิธี.เป็นครั้งแรกที่ใช้วิธีทำให้การใช้ชนิดมูลฐานจับและทิ้งที่ใช้สำหรับการตรวจสอบการประเมินผลของการแสดงออกทางความคิดเห็น.
ที่แสดงออก X =จับ N /ม.จะประเมินในการที่ tuple {}ที่ว่าเป็นข้อผิดพลาด: Manifest ในกรณีนี้ระยะสั้น:


จับได้แม้จะเป็นที่เมตา - ทำงานซึ่งการเปลี่ยนแปลงที่ปกติการประเมินรุ่นโดยการแปลงข้อผิดพลาดในระยะสั้นซึ่งสามารถเปลี่ยนแปลงโดยที่โปรแกรม.
หากไม่มีข้อผิดพลาดเกิดขึ้นแล้วจะทำให้การประเมินจับ expr เป็นที่เดียวกับที่การประเมิน expr .

โบราณที่โยน( expr )จะประเมิน expr ซึ่งก็จะกลายเป็นที่คืนค่าของที่ใส่เครื่องหมายวงเล็บจับ.
การใช้จับและไม่ไกลสามารถเขียนโปรแกรมเพื่อตรวจสอบและแก้ไขข้อผิดพลาด ภายใน ท้องถิ่นที่กระบวนการ.
ที่สองเกิดข้อผิดพลาดการจัดการกลไกกำหนดจะเกิดอะไรขึ้นเมื่อกระบวนการตาย.คิดว่าบางอย่างรหัสการประเมินในกระบวนการสร้างข้อผิดพลาดและข้อผิดพลาดนี้ไม่มีการใช้กลไกการจับได้อธิบายไว้ข้างต้น.
หากหมายเลขโพรเซส 1 จะประเมินที่แสดงออกลิงค์(โพรเซส 2 )แล้วที่เชื่อมโยงระหว่างสองคนนี้กระบวนการ.
เมื่อกระบวนการตายเป็นการถ่ายทอดสัญญาณที่ข้อความที่มีข้อมูลเกี่ยวกับว่าทำไมมันตายทั้งหมดกระบวนการในระบบที่มีการเชื่อมโยง.ดังนั้นหากโพรเซส 1 ตายข้อความที่ประกอบด้วยเหตุผลที่ทำให้การตายจะถูกส่งไปให้กับกระบวนการที่ pid2 . Link คือสมมาตรดังนั้นหากโพรเซส 2 ตายข้อความแสดงข้อผิดพลาดที่จะถูกส่งไปยัง pid1 .

เช่นจอมอนิเตอร์ฟังก์ชันที่()สร้างลากโปรเซสเซอร์แบบคู่ขนาน หนึ่งในขั้นตอนเหล่านี้จะประเมินการแสดงที่ม.: F ( args )ทำหน้าที่ตรวจสอบอื่นๆที่กระบวนการที่จะทำการประเมินผลตายกระบวนการใหม่จะถูกสร้างขึ้นโดยการตรวจสอบ process.

**

ที่โบราณ process_flag ( trap_exist ,ทรู)ช่วยให้การประเมินกระบวนการในการดักจับออกจากข้อความ spawn_link สร้างใหม่แบบคู่ขนานและลิงค์ไปยังเป็นการดำเนินการที่ปรมาณู.
ที่สามเกิดข้อผิดพลาดการจัดการกลไกการใช้ในการจับความผิดพลาดเกิดขึ้นเมื่อไม่ได้กำหนดการทำงานมีการเรียก. หากความพยายามที่จะทำการประเมินผลม.F (พนาราม)และไม่มีรหัสสำหรับโมดูลม.ได้รับการโหลดเข้าสู่ระบบแล้วจะทำงาน undefined_function (ม., F , args )ในโมดูล error_handler คือ called

**

ที่จุดการบันทึกไว้นี้ไม่ใช่เฉพาะรหัสนี้แต่สิ่งที่สำคัญกว่าคือข้อเท็จจริงที่ว่าผู้ใช้สามารถตั้งโปรแกรมได้อย่างแน่นอนว่าจะเกิดอะไรขึ้นเมื่อโปรแกรมจะพยายามในการรันโค้ดที่ไม่มีการโหลดเข้าไปในระบบ.

แตกต่างกันตาม ประเภท ของระบบ,ตัวอย่างเช่นเอ็มเบ็ดเด็ดระบบหรือระบบการพัฒนาต้องใช้ ประเภท ที่แตกต่างกันไปของยุทธศาสตร์การโหลดโค้ด โรงแรมแห่งนี้สูงกว่ากลไกการทำให้กลยุทธ์การโหลดรหัสจะตั้งโปรแกรมได้โดยผู้ใช้ที่อยู่ในตัวของมันเอง Erlang เสร็จสิ้นแล้วหรือไม่.