---
title: "மஞ்சள் அறிக்கையின் EVM விவரக்குறிப்புகளைப் புரிந்துகொள்ளுதல்"
description: "எத்திரியத்தின் முறையான விவரக்குறிப்புகளான மஞ்சள் அறிக்கையில், எத்திரியம் மெய்நிகர் இயந்திரத்தை (EVM) விளக்கும் பகுதியைப் புரிந்துகொள்ளுதல்."
author: "qbzzt"
tags: ["evm"]
skill: intermediate
breadcrumb: "மஞ்சள் அறிக்கை EVM"
lang: ta
published: 2022-05-15
---

[மஞ்சள் அறிக்கை](https://ethereum.github.io/yellowpaper/paper.pdf) என்பது எத்திரியத்திற்கான முறையான விவரக்குறிப்பாகும். [EIP செயல்முறையால்](/eips/) திருத்தப்பட்ட இடங்களைத் தவிர, அனைத்தும் எவ்வாறு செயல்படுகின்றன என்பதற்கான சரியான விளக்கத்தை இது கொண்டுள்ளது. இது ஒரு கணிதக் கட்டுரையாக எழுதப்பட்டுள்ளது, இதில் நிரலாளர்களுக்குப் பரிச்சயமில்லாத சொற்கள் இருக்கலாம். இந்தக் கட்டுரையில் அதை எவ்வாறு வாசிப்பது என்பதையும், அதன் நீட்சியாகத் தொடர்புடைய பிற கணிதக் கட்டுரைகளை எவ்வாறு வாசிப்பது என்பதையும் நீங்கள் கற்றுக்கொள்வீர்கள்.

## எந்த மஞ்சள் அறிக்கை? {#which-yellow-paper}

எத்திரியத்தில் உள்ள மற்ற அனைத்தையும் போலவே, மஞ்சள் அறிக்கையும் காலப்போக்கில் உருவாகிறது. ஒரு குறிப்பிட்ட பதிப்பைக் குறிப்பிடுவதற்காக, [எழுதும் நேரத்தில் இருந்த தற்போதைய பதிப்பை](https://ethereum.github.io/yellowpaper/paper.pdf) நான் பதிவேற்றியுள்ளேன். நான் பயன்படுத்தும் பிரிவு, பக்கம் மற்றும் சமன்பாட்டு எண்கள் அந்தப் பதிப்பையே குறிக்கும். இந்த ஆவணத்தை வாசிக்கும்போது அதை வேறொரு சாளரத்தில் திறந்து வைத்திருப்பது நல்லது.

### ஏன் EVM? {#why-the-evm}

அசல் மஞ்சள் அறிக்கை எத்திரியத்தின் வளர்ச்சியின் தொடக்கத்திலேயே எழுதப்பட்டது. பிணையத்தைப் பாதுகாப்பதற்காக முதலில் பயன்படுத்தப்பட்ட அசல் பணிச் சான்று (PoW) அடிப்படையிலான ஒருமித்த வழிமுறையை இது விவரிக்கிறது. இருப்பினும், எத்திரியம் செப்டம்பர் 2022 இல் பணிச் சான்று முறையை நிறுத்திவிட்டு, உரிமைச் சான்று (PoS) அடிப்படையிலான ஒருமித்த கருத்தைப் பயன்படுத்தத் தொடங்கியது. இந்த வழிகாட்டி எத்திரியம் மெய்நிகர் இயந்திரத்தை வரையறுக்கும் மஞ்சள் அறிக்கையின் பகுதிகளில் கவனம் செலுத்தும். உரிமைச் சான்று முறைக்கு மாறியதால் EVM மாறவில்லை (DIFFICULTY செயல்பாட்டுக் குறியீட்டின் திரும்பப் பெறும் மதிப்பைத் தவிர).

## 9 செயலாக்க மாதிரி

இந்தப் பிரிவு (பக். 14-16) EVM இன் பெரும்பாலான வரையறைகளை உள்ளடக்கியது.

_கணினி நிலை (system state)_ என்ற சொல், கணினியை இயக்குவதற்கு நீங்கள் தெரிந்துகொள்ள வேண்டிய அனைத்தையும் உள்ளடக்கியது. ஒரு வழக்கமான கணினியில், இது நினைவகம், பதிவேடுகளின் உள்ளடக்கம் போன்றவற்றைக் குறிக்கிறது.

ஒரு [டூரிங் இயந்திரம் (Turing machine)](https://en.wikipedia.org/wiki/Turing_machine) என்பது ஒரு கணக்கீட்டு மாதிரியாகும். அடிப்படையில், இது ஒரு கணினியின் எளிமைப்படுத்தப்பட்ட பதிப்பாகும், இது ஒரு சாதாரண கணினி செய்யக்கூடிய அதே கணக்கீடுகளைச் செய்யும் திறனைக் கொண்டுள்ளது என நிரூபிக்கப்பட்டுள்ளது (ஒரு கணினி கணக்கிடக்கூடிய அனைத்தையும் ஒரு டூரிங் இயந்திரமும் கணக்கிட முடியும், மேலும் நேர்மாறாகவும்). எது கணக்கிடக்கூடியது மற்றும் எது கணக்கிட முடியாதது என்பது பற்றிய பல்வேறு தேற்றங்களை நிரூபிக்க இந்த மாதிரி எளிதாக்குகிறது.

[டூரிங்-முழுமையானது (Turing-complete)](https://en.wikipedia.org/wiki/Turing_completeness) என்ற சொல், ஒரு டூரிங் இயந்திரம் செய்யும் அதே கணக்கீடுகளைச் செய்யக்கூடிய ஒரு கணினியைக் குறிக்கிறது. டூரிங் இயந்திரங்கள் முடிவிலி சுழல்களில் (infinite loops) சிக்கிக்கொள்ளலாம், ஆனால் EVM-ஆல் அவ்வாறு செய்ய முடியாது, ஏனெனில் அதன் எரிவாயு தீர்ந்துவிடும், எனவே இது ஒரு பகுதி-டூரிங்-முழுமையானது (quasi-Turing-complete) மட்டுமே.
## 9.1 அடிப்படைகள் {#91-basics}

இந்தப் பிரிவு EVM இன் அடிப்படைகளையும், பிற கணக்கீட்டு மாதிரிகளுடன் அது எவ்வாறு ஒப்பிடப்படுகிறது என்பதையும் வழங்குகிறது.

ஒரு [ஸ்டாக் இயந்திரம் (stack machine)](https://en.wikipedia.org/wiki/Stack_machine) என்பது இடைநிலைத் தரவைப் பதிவேடுகளில் அல்லாமல், ஒரு [**ஸ்டாக்கில் (stack)**](<https://en.wikipedia.org/wiki/Stack_(abstract_data_type)>) சேமிக்கும் கணினியாகும். மெய்நிகர் இயந்திரங்களுக்கு இதுவே விரும்பப்படும் கட்டமைப்பாகும், ஏனெனில் இதைச் செயல்படுத்துவது எளிது, அதாவது பிழைகள் மற்றும் பாதுகாப்பு பாதிப்புகள் ஏற்படுவதற்கான வாய்ப்புகள் மிகக் குறைவு. ஸ்டாக்கில் உள்ள நினைவகம் 256-பிட் சொற்களாகப் பிரிக்கப்பட்டுள்ளது. கெக்காக்-256 ஹாஷ் செய்தல் மற்றும் நீள்வட்ட வளைவு கணக்கீடுகள் போன்ற எத்திரியத்தின் முக்கிய கிரிப்டோகிராஃபிக் செயல்பாடுகளுக்கு இது வசதியாக இருப்பதால் இது தேர்ந்தெடுக்கப்பட்டது. ஸ்டாக்கின் அதிகபட்ச அளவு 1024 உருப்படிகள் (1024 x 256 பிட்கள்) ஆகும். செயல்பாட்டுக் குறியீடுகள் செயல்படுத்தப்படும்போது, அவை வழக்கமாக அவற்றின் அளவுருக்களை ஸ்டாக்கிலிருந்து பெறுகின்றன. ஸ்டாக்கில் உள்ள கூறுகளை மறுசீரமைப்பதற்காகவே பிரத்யேகமாக `POP` (ஸ்டாக்கின் மேலிருந்து உருப்படியை அகற்றும்), `DUP_N` (ஸ்டாக்கில் உள்ள N-ஆவது உருப்படியை நகலெடுக்கும்) போன்ற செயல்பாட்டுக் குறியீடுகள் உள்ளன.

EVM-இல் **நினைவகம் (memory)** எனப்படும் ஒரு தற்காலிக இடமும் உள்ளது, இது செயலாக்கத்தின் போது தரவைச் சேமிக்கப் பயன்படுகிறது. இந்த நினைவகம் 32-பைட் சொற்களாக ஒழுங்கமைக்கப்பட்டுள்ளது. அனைத்து நினைவக இடங்களும் பூஜ்ஜியமாகத் தொடங்கப்படுகின்றன. நினைவகத்தில் ஒரு சொல்லைச் சேர்க்க இந்த [Yul](https://docs.soliditylang.org/en/latest/yul.html) குறியீட்டை நீங்கள் இயக்கினால், அது சொல்லில் உள்ள காலி இடத்தை பூஜ்ஜியங்களால் நிரப்புவதன் மூலம் 32 பைட்டுகள் நினைவகத்தை நிரப்பும், அதாவது, இது ஒரு சொல்லை உருவாக்குகிறது - 0-29 இடங்களில் பூஜ்ஜியங்களுடனும், 30-இல் 0x60 உடனும், 31-இல் 0xA7 உடனும்.

```yul
mstore(0, 0x60A7)
```

நினைவகத்துடன் தொடர்புகொள்வதற்கு EVM வழங்கும் மூன்று செயல்பாட்டுக் குறியீடுகளில் `mstore` ஒன்றாகும் - இது ஒரு சொல்லை நினைவகத்தில் ஏற்றுகிறது. மற்ற இரண்டு `mstore8` ஆகும், இது ஒரு பைட்டை நினைவகத்தில் ஏற்றுகிறது, மற்றும் `mload` ஆகும், இது ஒரு சொல்லை நினைவகத்திலிருந்து ஸ்டாக்கிற்கு நகர்த்துகிறது.

EVM-இல் கணினி நிலையின் ஒரு பகுதியாகப் பராமரிக்கப்படும் ஒரு தனி நிலையான **சேமிப்பக (storage)** மாதிரியும் உள்ளது - இந்த நினைவகம் சொல் வரிசைகளாக (ஸ்டாக்கில் உள்ள சொல்-முகவரியிடக்கூடிய பைட் வரிசைகளுக்கு மாறாக) ஒழுங்கமைக்கப்பட்டுள்ளது. இந்தச் சேமிப்பகத்தில்தான் ஒப்பந்தங்கள் நிலையான தரவை வைத்திருக்க முடியும் - ஒரு ஒப்பந்தம் அதன் சொந்தச் சேமிப்பகத்துடன் மட்டுமே தொடர்புகொள்ள முடியும். சேமிப்பகம் திறவுகோல்-மதிப்பு (key-value) மேப்பிங்குகளாக ஒழுங்கமைக்கப்பட்டுள்ளது.

மஞ்சள் அறிக்கையின் இந்தப் பிரிவில் இது குறிப்பிடப்படவில்லை என்றாலும், நான்காவது வகையான நினைவகம் இருப்பதையும் தெரிந்துகொள்வது பயனுள்ளதாக இருக்கும். **அழைப்புத் தரவு (Calldata)** என்பது ஒரு பரிவர்த்தனையின் `data` அளவுருவுடன் அனுப்பப்படும் மதிப்பைச் சேமிக்கப் பயன்படும் பைட்-முகவரியிடக்கூடிய படிக்க-மட்டுமேயான நினைவகமாகும். `calldata` ஐ நிர்வகிப்பதற்கு EVM குறிப்பிட்ட செயல்பாட்டுக் குறியீடுகளைக் கொண்டுள்ளது. `calldatasize` தரவின் அளவைத் திருப்பித் தருகிறது. `calldataload` தரவை ஸ்டாக்கில் ஏற்றுகிறது. `calldatacopy` தரவை நினைவகத்தில் நகலெடுக்கிறது.

நிலையான [வான் நியூமன் கட்டமைப்பு (Von Neumann architecture)](https://en.wikipedia.org/wiki/Von_Neumann_architecture) குறியீட்டையும் தரவையும் ஒரே நினைவகத்தில் சேமிக்கிறது. பாதுகாப்புக் காரணங்களுக்காக EVM இந்தத் தரநிலையைப் பின்பற்றுவதில்லை - தற்காலிக நினைவகத்தைப் பகிர்வது நிரல் குறியீட்டை மாற்றுவதை சாத்தியமாக்குகிறது. அதற்குப் பதிலாக, குறியீடு சேமிப்பகத்தில் சேமிக்கப்படுகிறது.

நினைவகத்திலிருந்து குறியீடு செயல்படுத்தப்படும் இரண்டு நிகழ்வுகள் மட்டுமே உள்ளன:

- ஒரு ஒப்பந்தம் மற்றொரு ஒப்பந்தத்தை உருவாக்கும்போது ([`CREATE`](https://www.evm.codes/#f0) அல்லது [`CREATE2`](https://www.evm.codes/#f5) ஐப் பயன்படுத்தி), ஒப்பந்த ஆக்கிக்கான குறியீடு நினைவகத்திலிருந்து வருகிறது.
- _எந்தவொரு_ ஒப்பந்தத்தையும் உருவாக்கும்போது, ஆக்கிக் குறியீடு இயங்குகிறது, பின்னர் உண்மையான ஒப்பந்தத்தின் குறியீட்டுடன் திரும்புகிறது, இதுவும் நினைவகத்திலிருந்தே வருகிறது.

விதிவிலக்கான செயலாக்கம் (exceptional execution) என்ற சொல், தற்போதைய ஒப்பந்தத்தின் செயலாக்கத்தை நிறுத்தும் ஒரு விதிவிலக்கைக் குறிக்கிறது.

## 9.2 கட்டணங்களின் கண்ணோட்டம் {#92-fees-overview}

எரிவாயு கட்டணங்கள் எவ்வாறு கணக்கிடப்படுகின்றன என்பதை இந்தப் பிரிவு விளக்குகிறது. இதில் மூன்று செலவுகள் உள்ளன:

### செயல்பாட்டுக் குறியீட்டுச் செலவு

குறிப்பிட்ட செயல்பாட்டுக் குறியீட்டின் உள்ளார்ந்த செலவு. இந்த மதிப்பைப் பெற, பின்னிணைப்பு H-இல் (பக். 29, சமன்பாடு (329)-இன் கீழ்) செயல்பாட்டுக் குறியீட்டின் செலவுக் குழுவைக் கண்டறியவும், மேலும் சமன்பாடு (326)-இல் செலவுக் குழுவைக் கண்டறியவும். இது உங்களுக்கு ஒரு செலவுச் சார்பை (cost function) வழங்குகிறது, இது பெரும்பாலான சந்தர்ப்பங்களில் பின்னிணைப்பு G-இல் (பக். 28) உள்ள அளவுருக்களைப் பயன்படுத்துகிறது.

எடுத்துக்காட்டாக, [`CALLDATACOPY`](https://www.evm.codes/#37) என்ற செயல்பாட்டுக் குறியீடு _W<sub>copy</sub>_ குழுவின் உறுப்பினராகும். அந்தக் குழுவிற்கான செயல்பாட்டுக் குறியீட்டுச் செலவு _G<sub>verylow</sub>+G<sub>copy</sub>×⌈μ<sub>s</sub>[2]÷32⌉_ ஆகும். பின்னிணைப்பு G-ஐப் பார்க்கும்போது, இரண்டு மாறிலிகளும் 3 என்பதைக் காண்கிறோம், இது நமக்கு _3+3×⌈μ<sub>s</sub>[2]÷32⌉_ ஐ வழங்குகிறது.

நாம் இன்னும் _⌈μ<sub>s</sub>[2]÷32⌉_ என்ற கோவையை (expression) புரிந்துகொள்ள வேண்டும். வெளிப்புறப் பகுதியான _⌈ \<value\> ⌉_ என்பது சீலிங் சார்பு (ceiling function) ஆகும், இது ஒரு மதிப்பைக் கொடுத்தால், அந்த மதிப்பை விடச் சிறியதாக இல்லாத மிகச்சிறிய முழு எண்ணைத் திருப்பித் தரும் ஒரு சார்பாகும். எடுத்துக்காட்டாக, _⌈2.5⌉ = ⌈3⌉ = 3_. உட்புறப் பகுதி _μ<sub>s</sub>[2]÷32_ ஆகும். பக். 3-இல் உள்ள பிரிவு 3-ஐப் (மரபுகள்) பார்க்கும்போது, _μ_ என்பது இயந்திர நிலையாகும். இயந்திர நிலை பக். 15-இல் உள்ள பிரிவு 9.4.1-இல் வரையறுக்கப்பட்டுள்ளது. அந்தப் பிரிவின்படி, இயந்திர நிலை அளவுருக்களில் ஒன்று ஸ்டாக்கிற்கான _s_ ஆகும். அனைத்தையும் ஒன்றாக இணைத்துப் பார்க்கும்போது, _μ<sub>s</sub>[2]_ என்பது ஸ்டாக்கில் உள்ள இடம் #2 என்று தோன்றுகிறது. [செயல்பாட்டுக் குறியீட்டைப்](https://www.evm.codes/#37) பார்க்கும்போது, ஸ்டாக்கில் உள்ள இடம் #2 என்பது பைட்டுகளில் உள்ள தரவின் அளவாகும். W<sub>copy</sub> குழுவில் உள்ள மற்ற செயல்பாட்டுக் குறியீடுகளான [`CODECOPY`](https://www.evm.codes/#39) மற்றும் [`RETURNDATACOPY`](https://www.evm.codes/#3e) ஆகியவற்றைப் பார்க்கும்போது, அவையும் அதே இடத்தில் தரவின் அளவைக் கொண்டுள்ளன. எனவே _⌈μ<sub>s</sub>[2]÷32⌉_ என்பது நகலெடுக்கப்படும் தரவைச் சேமிக்கத் தேவையான 32 பைட் சொற்களின் எண்ணிக்கையாகும். அனைத்தையும் ஒன்றாக இணைத்தால், [`CALLDATACOPY`](https://www.evm.codes/#37) இன் உள்ளார்ந்த செலவு 3 எரிவாயு மற்றும் நகலெடுக்கப்படும் தரவின் ஒவ்வொரு சொல்லுக்கும் 3 ஆகும்.
### இயங்கும் செலவு {#running-cost}

நாம் அழைக்கும் குறியீட்டை இயக்குவதற்கான செலவு.

- [`CREATE`](https://www.evm.codes/#f0) மற்றும் [`CREATE2`](https://www.evm.codes/#f5) ஆகியவற்றின் விஷயத்தில், புதிய ஒப்பந்தத்திற்கான ஆக்கி.
- [`CALL`](https://www.evm.codes/#f1), [`CALLCODE`](https://www.evm.codes/#f2), [`STATICCALL`](https://www.evm.codes/#fa), அல்லது [`DELEGATECALL`](https://www.evm.codes/#f4) ஆகியவற்றின் விஷயத்தில், நாம் அழைக்கும் ஒப்பந்தம்.

### நினைவகத்தை விரிவுபடுத்துவதற்கான செலவு

நினைவகத்தை விரிவுபடுத்துவதற்கான செலவு (தேவைப்பட்டால்).

சமன்பாடு 326-இல், இந்த மதிப்பு _C<sub>mem</sub>(μ<sub>i</sub>')-C<sub>mem</sub>(μ<sub>i</sub>)_ என எழுதப்பட்டுள்ளது. மீண்டும் பிரிவு 9.4.1-ஐப் பார்க்கும்போது, _μ<sub>i</sub>_ என்பது நினைவகத்தில் உள்ள சொற்களின் எண்ணிக்கை என்பதைக் காண்கிறோம். எனவே _μ<sub>i</sub>_ என்பது செயல்பாட்டுக் குறியீட்டிற்கு முன் நினைவகத்தில் உள்ள சொற்களின் எண்ணிக்கை மற்றும் _μ<sub>i</sub>'_ என்பது செயல்பாட்டுக் குறியீட்டிற்குப் பின் நினைவகத்தில் உள்ள சொற்களின் எண்ணிக்கை ஆகும்.

_C<sub>mem</sub>_ என்ற சார்பு சமன்பாடு 328-இல் வரையறுக்கப்பட்டுள்ளது: _C<sub>mem</sub>(a) = G<sub>memory</sub> × a + ⌊a<sup>2</sup> ÷ 512⌋_. _⌊x⌋_ என்பது ஃப்ளோர் சார்பு (floor function) ஆகும், இது ஒரு மதிப்பைக் கொடுத்தால், அந்த மதிப்பை விடப் பெரியதாக இல்லாத மிகப்பெரிய முழு எண்ணைத் திருப்பித் தரும் ஒரு சார்பாகும். எடுத்துக்காட்டாக, _⌊2.5⌋ = ⌊2⌋ = 2._ _a < √512_ ஆக இருக்கும்போது, _a<sup>2</sup> < 512_ ஆகும், மேலும் ஃப்ளோர் சார்பின் முடிவு பூஜ்ஜியமாகும். எனவே முதல் 22 சொற்களுக்கு (704 பைட்டுகள்), தேவையான நினைவகச் சொற்களின் எண்ணிக்கையுடன் செலவு நேர்கோட்டில் (linearly) உயர்கிறது. அந்தப் புள்ளிக்கு அப்பால் _⌊a<sup>2</sup> ÷ 512⌋_ நேர்மறையானது. தேவையான நினைவகம் போதுமான அளவு அதிகமாக இருக்கும்போது, எரிவாயு செலவு நினைவகத்தின் அளவின் வர்க்கத்திற்கு (square) விகிதாசாரமாக இருக்கும்.

**குறிப்பு:** இந்தக் காரணிகள் _உள்ளார்ந்த_ எரிவாயு செலவை மட்டுமே பாதிக்கின்றன - ஒரு இறுதிப் பயனர் எவ்வளவு செலுத்த வேண்டும் என்பதைத் தீர்மானிக்கும் கட்டணச் சந்தை அல்லது மதிப்பீட்டாளர்களுக்கான (validators) உதவிக்குறிப்புகளை (tips) இது கணக்கில் எடுத்துக்கொள்வதில்லை - இது EVM-இல் ஒரு குறிப்பிட்ட செயல்பாட்டை இயக்குவதற்கான மூலச் செலவு மட்டுமே.

[எரிவாயு பற்றி மேலும் படிக்கவும்](/developers/docs/gas/).
## 9.3 செயலாக்கச் சூழல்

செயலாக்கச் சூழல் என்பது ஒரு டியூப்பிள் (tuple), _I_ ஆகும், இது தொகுதிச்சங்கிலி நிலை அல்லது EVM இன் பகுதியாக இல்லாத தகவல்களை உள்ளடக்கியது.

| அளவுரு | தரவை அணுகுவதற்கான செயல்பாட்டுக் குறியீடு | தரவை அணுகுவதற்கான Solidity குறியீடு |
| --------------- | ---------------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
| _I<sub>a</sub>_ | [`ADDRESS`](https://www.evm.codes/#30) | `address(this)` |
| _I<sub>o</sub>_ | [`ORIGIN`](https://www.evm.codes/#32) | `tx.origin` |
| _I<sub>p</sub>_ | [`GASPRICE`](https://www.evm.codes/#3a) | `tx.gasprice` |
| _I<sub>d</sub>_ | [`CALLDATALOAD`](https://www.evm.codes/#35), போன்றவை. | `msg.data` |
| _I<sub>s</sub>_ | [`CALLER`](https://www.evm.codes/#33) | `msg.sender` |
| _I<sub>v</sub>_ | [`CALLVALUE`](https://www.evm.codes/#34) | `msg.value` |
| _I<sub>b</sub>_ | [`CODECOPY`](https://www.evm.codes/#39) | `address(this).code` |
| _I<sub>H</sub>_ | [`NUMBER`](https://www.evm.codes/#43) மற்றும் [`DIFFICULTY`](https://www.evm.codes/#44) போன்ற தொகுதித் தலைப்புப் புலங்கள் | `block.number`, `block.difficulty`, போன்றவை. |
| _I<sub>e</sub>_ | ஒப்பந்தங்களுக்கு இடையிலான அழைப்புகளுக்கான அழைப்பு ஸ்டாக்கின் ஆழம் (ஒப்பந்த உருவாக்கம் உட்பட) |
| _I<sub>w</sub>_ | EVM நிலையை மாற்ற அனுமதிக்கப்படுகிறதா, அல்லது அது நிலையாக இயங்குகிறதா |

பிரிவு 9 இன் மீதமுள்ள பகுதியைப் புரிந்துகொள்ள வேறு சில அளவுருக்கள் அவசியமாகும்:

| அளவுரு | வரையறுக்கப்பட்டுள்ள பிரிவு | பொருள் |
| --------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| _σ_ | 2 (பக். 2, சமன்பாடு 1) | தொகுதிச்சங்கிலியின் நிலை |
| _g_ | 9.3 (பக். 14) | மீதமுள்ள எரிவாயு |
| _A_ | 6.1 (பக். 9) | திரட்டப்பட்ட துணைநிலை (பரிவர்த்தனை முடிவடையும் போது திட்டமிடப்பட்ட மாற்றங்கள்) |
| _o_ | 9.3 (பக். 14) | வெளியீடு - உள் பரிவர்த்தனையின் போது (ஒரு ஒப்பந்தம் மற்றொன்றை அழைக்கும் போது) மற்றும் காட்சிச் சார்புகளுக்கான (view functions) அழைப்புகளின் போது (நீங்கள் தகவலை மட்டுமே கேட்கிறீர்கள், எனவே பரிவர்த்தனைக்காகக் காத்திருக்கத் தேவையில்லை) திருப்பித் தரப்படும் முடிவு |
## 9.4 செயலாக்கக் கண்ணோட்டம்

இப்போது அனைத்து ஆரம்பக் கட்டத் தகவல்களும் நம்மிடம் உள்ளதால், EVM எவ்வாறு செயல்படுகிறது என்பதைப் பற்றி நாம் இறுதியாகப் பார்க்கத் தொடங்கலாம்.

சமன்பாடுகள் 146-151 EVM ஐ இயக்குவதற்கான ஆரம்ப நிபந்தனைகளை நமக்கு வழங்குகின்றன:

| குறியீடு | ஆரம்ப மதிப்பு | பொருள் |
| ---------------- | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| _μ<sub>g</sub>_ | _g_ | மீதமுள்ள எரிவாயு |
| _μ<sub>pc</sub>_ | _0_ | நிரல் கவுண்டர் (Program counter), செயல்படுத்த வேண்டிய அடுத்த அறிவுறுத்தலின் முகவரி |
| _μ<sub>m</sub>_ | _(0, 0, ...)_ | நினைவகம், அனைத்தும் பூஜ்ஜியங்களாகத் தொடங்கப்படுகின்றன |
| _μ<sub>i</sub>_ | _0_ | பயன்படுத்தப்பட்ட மிக உயர்ந்த நினைவக இடம் |
| _μ<sub>s</sub>_ | _()_ | ஸ்டாக், ஆரம்பத்தில் காலியாக இருக்கும் |
| _μ<sub>o</sub>_ | _∅_ | வெளியீடு, திரும்பப் பெறும் தரவுடன் ([`RETURN`](https://www.evm.codes/#f3) அல்லது [`REVERT`](https://www.evm.codes/#fd)) அல்லது அது இல்லாமல் ([`STOP`](https://www.evm.codes/#00) அல்லது [`SELFDESTRUCT`](https://www.evm.codes/#ff)) நாம் நிறுத்தும் வரை வெற்றுத் தொகுப்பாக இருக்கும். |

செயலாக்கத்தின் போது ஒவ்வொரு நேரப் புள்ளியிலும் நான்கு சாத்தியமான நிபந்தனைகள் உள்ளன என்பதையும், அவற்றுடன் என்ன செய்ய வேண்டும் என்பதையும் சமன்பாடு 152 நமக்குக் கூறுகிறது:

1.  `Z(σ,μ,A,I)`. ஒரு செயல்பாடு தவறான நிலை மாற்றத்தை (invalid state transition) உருவாக்குகிறதா என்பதைச் சோதிக்கும் ஒரு சார்பை Z குறிக்கிறது ([விதிவிலக்கான நிறுத்தம்](#942-exceptional-halt) என்பதைப் பார்க்கவும்). இது True என மதிப்பிடப்பட்டால், மாற்றங்கள் செயல்படுத்தப்படாததால் புதிய நிலை பழைய நிலையைப் போலவே இருக்கும் (எரிவாயு எரிக்கப்படுவதைத் தவிர).
2.  செயல்படுத்தப்படும் செயல்பாட்டுக் குறியீடு [`REVERT`](https://www.evm.codes/#fd) ஆக இருந்தால், புதிய நிலை பழைய நிலையைப் போலவே இருக்கும், சிறிது எரிவாயு இழக்கப்படும்.
3.  செயல்பாடுகளின் வரிசை முடிவடைந்தால், அது [`RETURN`](https://www.evm.codes/#f3) மூலம் குறிக்கப்படும், நிலை புதிய நிலைக்குப் புதுப்பிக்கப்படும்.
4.  நாம் 1-3 இறுதி நிபந்தனைகளில் ஒன்றில் இல்லை என்றால், தொடர்ந்து இயங்கவும்.
## 9.4.1 இயந்திர நிலை {#941-machine-state}

இந்தப் பிரிவு இயந்திர நிலையை இன்னும் விரிவாக விளக்குகிறது. _w_ என்பது தற்போதைய செயல்பாட்டுக் குறியீடு என்பதை இது குறிப்பிடுகிறது. _μ<sub>pc</sub>_ ஆனது குறியீட்டின் நீளமான _||I<sub>b</sub>||_ ஐ விடக் குறைவாக இருந்தால், அந்த பைட் (_I<sub>b</sub>[μ<sub>pc</sub>]_) செயல்பாட்டுக் குறியீடாகும். இல்லையெனில், செயல்பாட்டுக் குறியீடு [`STOP`](https://www.evm.codes/#00) என வரையறுக்கப்படுகிறது.

இது ஒரு [ஸ்டாக் இயந்திரம்](https://en.wikipedia.org/wiki/Stack_machine) என்பதால், ஒவ்வொரு செயல்பாட்டுக் குறியீட்டாலும் வெளியேற்றப்பட்ட (_δ_) மற்றும் உள்ளே தள்ளப்பட்ட (_α_) உருப்படிகளின் எண்ணிக்கையை நாம் கண்காணிக்க வேண்டும்.

## 9.4.2 விதிவிலக்கான நிறுத்தம்

இந்தப் பிரிவு _Z_ சார்பை வரையறுக்கிறது, இது எப்போது அசாதாரணமான நிறுத்தம் ஏற்படும் என்பதைக் குறிப்பிடுகிறது. இது ஒரு [பூலியன் (Boolean)](https://en.wikipedia.org/wiki/Boolean_data_type) சார்பாகும், எனவே இது [தர்க்கரீதியான 'அல்லது' (logical or) என்பதற்கு _∨_ ஐயும்](https://en.wikipedia.org/wiki/Logical_disjunction) [தர்க்கரீதியான 'மற்றும்' (logical and) என்பதற்கு _∧_ ஐயும்](https://en.wikipedia.org/wiki/Logical_conjunction) பயன்படுத்துகிறது.

இந்த நிபந்தனைகளில் ஏதேனும் ஒன்று உண்மையாக இருந்தால், நமக்கு ஒரு விதிவிலக்கான நிறுத்தம் ஏற்படும்:

- **_μ<sub>g</sub> < C(σ,μ,A,I)_**
  பிரிவு 9.2-இல் நாம் பார்த்தபடி, _C_ என்பது எரிவாயு செலவைக் குறிப்பிடும் சார்பாகும். அடுத்த செயல்பாட்டுக் குறியீட்டை இயக்குவதற்குப் போதுமான எரிவாயு மீதமில்லை.

- **_δ<sub>w</sub>=∅_**
  ஒரு செயல்பாட்டுக் குறியீட்டிற்காக வெளியேற்றப்பட்ட உருப்படிகளின் எண்ணிக்கை வரையறுக்கப்படவில்லை என்றால், அந்தச் செயல்பாட்டுக் குறியீடே வரையறுக்கப்படவில்லை என்று அர்த்தம்.

- **_|| μ<sub>s</sub> || < δ<sub>w</sub>_**
  ஸ்டாக் அண்டர்ஃப்ளோ (Stack underflow), தற்போதைய செயல்பாட்டுக் குறியீட்டிற்கு ஸ்டாக்கில் போதுமான உருப்படிகள் இல்லை.

- **_w = JUMP ∧ μ<sub>s</sub>[0]∉D(I<sub>b</sub>)_**
  செயல்பாட்டுக் குறியீடு [`JUMP`](https://www.evm.codes/#56) ஆகவும், முகவரி [`JUMPDEST`](https://www.evm.codes/#5b) ஆக இல்லாமலும் இருப்பது. இலக்கு [`JUMPDEST`](https://www.evm.codes/#5b) ஆக இருக்கும்போது _மட்டுமே_ தாவல்கள் (Jumps) செல்லுபடியாகும்.

- **_w = JUMPI ∧ μ<sub>s</sub>[1]≠0 ∧ μ<sub>s</sub>[0] ∉ D(I<sub>b</sub>)_**
  செயல்பாட்டுக் குறியீடு [`JUMPI`](https://www.evm.codes/#57) ஆக இருப்பது, நிபந்தனை உண்மையாக (பூஜ்ஜியமற்றதாக) இருப்பதால் தாவல் நிகழ வேண்டும், மேலும் முகவரி [`JUMPDEST`](https://www.evm.codes/#5b) ஆக இல்லை. இலக்கு [`JUMPDEST`](https://www.evm.codes/#5b) ஆக இருக்கும்போது _மட்டுமே_ தாவல்கள் செல்லுபடியாகும்.

- **_w = RETURNDATACOPY ∧ μ<sub>s</sub>[1]+μ<sub>s</sub>[2]>|| μ<sub>o</sub> ||_**
  செயல்பாட்டுக் குறியீடு [`RETURNDATACOPY`](https://www.evm.codes/#3e) ஆக இருப்பது. இந்தச் செயல்பாட்டுக் குறியீட்டில் ஸ்டாக் கூறு _μ<sub>s</sub>[1]_ என்பது திரும்பப் பெறும் தரவு இடையகத்திலிருந்து (return data buffer) வாசிப்பதற்கான ஆஃப்செட் (offset) ஆகும், மேலும் ஸ்டாக் கூறு _μ<sub>s</sub>[2]_ என்பது தரவின் நீளமாகும். திரும்பப் பெறும் தரவு இடையகத்தின் முடிவைத் தாண்டி வாசிக்க முயற்சிக்கும்போது இந்த நிபந்தனை ஏற்படுகிறது. அழைப்புத் தரவு (calldata) அல்லது குறியீட்டிற்கே இதே போன்ற நிபந்தனை இல்லை என்பதைக் கவனியுங்கள். அந்த இடையகங்களின் முடிவைத் தாண்டி வாசிக்க முயற்சிக்கும்போது உங்களுக்குப் பூஜ்ஜியங்களே கிடைக்கும்.

- **_|| μ<sub>s</sub> || - δ<sub>w</sub> + α<sub>w</sub> > 1024_**

  ஸ்டாக் அளவுமீறல் (Stack overflow). செயல்பாட்டுக் குறியீட்டை இயக்குவது 1024 உருப்படிகளுக்கு மேல் உள்ள ஸ்டாக்கை உருவாக்கினால், கைவிடவும்.

- **_¬I<sub>w</sub> ∧ W(w,μ)_**
  நாம் நிலையாக (statically) இயங்குகிறோமா ([¬ என்பது மறுப்பு (negation)](https://en.wikipedia.org/wiki/Negation) மற்றும் தொகுதிச்சங்கிலி நிலையை மாற்ற அனுமதிக்கப்படும்போது _I<sub>w</sub>_ உண்மையாக இருக்கும்)? அப்படியானால், நாம் நிலையை மாற்றும் செயல்பாட்டை முயற்சிக்கிறோம் என்றால், அது நடக்க முடியாது.

  _W(w,μ)_ சார்பு பின்னர் சமன்பாடு 159-இல் வரையறுக்கப்படுகிறது. இந்த நிபந்தனைகளில் ஏதேனும் ஒன்று உண்மையாக இருந்தால் _W(w,μ)_ உண்மையாக இருக்கும்:

  - **_w ∈ \{CREATE, CREATE2, SSTORE, SELFDESTRUCT}_**
    இந்தச் செயல்பாட்டுக் குறியீடுகள் புதிய ஒப்பந்தத்தை உருவாக்குவதன் மூலமாகவோ, ஒரு மதிப்பைச் சேமிப்பதன் மூலமாகவோ அல்லது தற்போதைய ஒப்பந்தத்தை அழிப்பதன் மூலமாகவோ நிலையை மாற்றுகின்றன.

  - **_LOG0≤w ∧ w≤LOG4_**
    நாம் நிலையாக அழைக்கப்பட்டால், பதிவு உள்ளீடுகளை (log entries) வெளியிட முடியாது.
    பதிவுச் செயல்பாட்டுக் குறியீடுகள் அனைத்தும் [`LOG0` (A0)](https://www.evm.codes/#a0) மற்றும் [`LOG4` (A4)](https://www.evm.codes/#a4) ஆகியவற்றுக்கு இடையேயான வரம்பில் உள்ளன.
    பதிவுச் செயல்பாட்டுக் குறியீட்டிற்குப் பின் உள்ள எண், பதிவு உள்ளீட்டில் எத்தனை தலைப்புகள் உள்ளன என்பதைக் குறிப்பிடுகிறது.
  - **_w=CALL ∧ μ<sub>s</sub>[2]≠0_**
    நீங்கள் நிலையாக இருக்கும்போது மற்றொரு ஒப்பந்தத்தை அழைக்கலாம், ஆனால் அவ்வாறு செய்தால் அதற்கு ETH-ஐப் பரிமாற்றம் செய்ய முடியாது.

- **_w = SSTORE ∧ μ<sub>g</sub> ≤ G<sub>callstipend</sub>_**
  உங்களிடம் G<sub>callstipend</sub> (பின்னிணைப்பு G-இல் 2300 என வரையறுக்கப்பட்டுள்ளது) எரிவாயுவை விட அதிகமாக இல்லாவிட்டால், நீங்கள் [`SSTORE`](https://www.evm.codes/#55) ஐ இயக்க முடியாது.
## 9.4.3 தாவல் இலக்கின் செல்லுபடியாகும் தன்மை

[`JUMPDEST`](https://www.evm.codes/#5b) செயல்பாட்டுக் குறியீடுகள் என்றால் என்ன என்பதை இங்கே முறையாக வரையறுக்கிறோம். நாம் 0x5B என்ற பைட் மதிப்பை மட்டும் தேட முடியாது, ஏனெனில் அது ஒரு PUSH-க்குள் இருக்கலாம் (எனவே அது தரவாக இருக்குமே தவிர செயல்பாட்டுக் குறியீடாக இருக்காது).

சமன்பாடு (162)-இல் நாம் _N(i,w)_ என்ற சார்பை வரையறுக்கிறோம். முதல் அளவுருவான _i_ என்பது செயல்பாட்டுக் குறியீட்டின் இருப்பிடமாகும். இரண்டாவது அளவுருவான _w_ என்பது செயல்பாட்டுக் குறியீடாகும். _w∈[PUSH1, PUSH32]_ ஆக இருந்தால், செயல்பாட்டுக் குறியீடு ஒரு PUSH என்று அர்த்தம் (சதுர அடைப்புக்குறிகள் இறுதிப்புள்ளிகளை உள்ளடக்கிய வரம்பை வரையறுக்கின்றன). அந்த நிலையில் அடுத்த செயல்பாட்டுக் குறியீடு _i+2+(w−PUSH1)_ இல் இருக்கும். [`PUSH1`](https://www.evm.codes/#60) க்கு நாம் இரண்டு பைட்டுகள் (PUSH மற்றும் ஒரு பைட் மதிப்பு) முன்னேற வேண்டும், [`PUSH2`](https://www.evm.codes/#61) க்கு நாம் மூன்று பைட்டுகள் முன்னேற வேண்டும், ஏனெனில் அது இரண்டு பைட் மதிப்பாகும், இதுபோலத் தொடரும். மற்ற அனைத்து EVM செயல்பாட்டுக் குறியீடுகளும் ஒரு பைட் நீளம் மட்டுமே கொண்டவை, எனவே மற்ற எல்லா நிகழ்வுகளிலும் _N(i,w)=i+1_ ஆகும்.

இந்தச் சார்பு சமன்பாடு (161)-இல் _D<sub>J</sub>(c,i)_ ஐ வரையறுக்கப் பயன்படுகிறது, இது செயல்பாட்டுக் குறியீட்டு இருப்பிடம் _i_-இல் தொடங்கி, குறியீடு _c_-இல் உள்ள அனைத்து செல்லுபடியாகும் தாவல் இலக்குகளின் [தொகுப்பாகும் (set)](<https://en.wikipedia.org/wiki/Set_(mathematics)>). இந்தச் சார்பு சுழல்நிலையாக (recursively) வரையறுக்கப்படுகிறது. _i≥||c||_ ஆக இருந்தால், நாம் குறியீட்டின் முடிவில் அல்லது அதற்குப் பிறகு இருக்கிறோம் என்று அர்த்தம். நாம் இனி எந்தத் தாவல் இலக்குகளையும் கண்டுபிடிக்கப் போவதில்லை, எனவே வெற்றுத் தொகுப்பைத் திருப்பித் தரவும்.

மற்ற எல்லா நிகழ்வுகளிலும், அடுத்த செயல்பாட்டுக் குறியீட்டிற்குச் சென்று அதிலிருந்து தொடங்கும் தொகுப்பைப் பெறுவதன் மூலம் குறியீட்டின் மீதமுள்ள பகுதியைப் பார்க்கிறோம். _c[i]_ என்பது தற்போதைய செயல்பாட்டுக் குறியீடாகும், எனவே _N(i,c[i])_ என்பது அடுத்த செயல்பாட்டுக் குறியீட்டின் இருப்பிடமாகும். எனவே _D<sub>J</sub>(c,N(i,c[i]))_ என்பது அடுத்த செயல்பாட்டுக் குறியீட்டில் தொடங்கும் செல்லுபடியாகும் தாவல் இலக்குகளின் தொகுப்பாகும். தற்போதைய செயல்பாட்டுக் குறியீடு `JUMPDEST` ஆக இல்லாவிட்டால், அந்தத் தொகுப்பை மட்டும் திருப்பித் தரவும். அது `JUMPDEST` ஆக இருந்தால், அதை முடிவுத் தொகுப்பில் சேர்த்து அதைத் திருப்பித் தரவும்.
## 9.4.4 சாதாரண நிறுத்தம் {#944-normal-halt}

நிறுத்தும் சார்பு _H_, மூன்று வகையான மதிப்புகளைத் திருப்பித் தரலாம்.

- நாம் ஒரு நிறுத்தச் செயல்பாட்டுக் குறியீட்டில் இல்லை என்றால், வெற்றுத் தொகுப்பான _∅_ ஐத் திருப்பித் தரவும். மரபுப்படி, இந்த மதிப்பு பூலியன் false எனப் பொருள் கொள்ளப்படுகிறது.
- வெளியீட்டை உருவாக்காத நிறுத்தச் செயல்பாட்டுக் குறியீடு நம்மிடம் இருந்தால் ([`STOP`](https://www.evm.codes/#00) அல்லது [`SELFDESTRUCT`](https://www.evm.codes/#ff)), பூஜ்ஜிய பைட் அளவுள்ள வரிசையைத் திரும்பப் பெறும் மதிப்பாகத் திருப்பித் தரவும். இது வெற்றுத் தொகுப்பிலிருந்து மிகவும் வேறுபட்டது என்பதைக் கவனியுங்கள். இந்த மதிப்பு EVM உண்மையில் நின்றது என்பதைக் குறிக்கிறது, வாசிப்பதற்குத் திரும்பப் பெறும் தரவு எதுவும் இல்லை.
- வெளியீட்டை உருவாக்கும் நிறுத்தச் செயல்பாட்டுக் குறியீடு நம்மிடம் இருந்தால் ([`RETURN`](https://www.evm.codes/#f3) அல்லது [`REVERT`](https://www.evm.codes/#fd)), அந்தச் செயல்பாட்டுக் குறியீட்டால் குறிப்பிடப்பட்ட பைட்டுகளின் வரிசையைத் திருப்பித் தரவும். இந்த வரிசை நினைவகத்திலிருந்து எடுக்கப்படுகிறது, ஸ்டாக்கின் மேற்புறத்தில் உள்ள மதிப்பு (_μ<sub>s</sub>[0]_) முதல் பைட்டாகும், அதற்குப் பின் உள்ள மதிப்பு (_μ<sub>s</sub>[1]_) நீளமாகும்.

## H.2 அறிவுறுத்தல் தொகுப்பு

EVM-இன் இறுதி உட்பிரிவான 9.5-க்குச் செல்வதற்கு முன், அறிவுறுத்தல்களைப் பார்ப்போம். அவை பக்கம் 30-இல் தொடங்கும் பின்னிணைப்பு H.2-இல் வரையறுக்கப்பட்டுள்ளன. அந்த குறிப்பிட்ட செயல்பாட்டுக் குறியீட்டுடன் மாறுவதாகக் குறிப்பிடப்படாத எதுவும் அப்படியே இருக்கும் என்று எதிர்பார்க்கப்படுகிறது. மாறும் மாறிகள் \<something\>′ எனக் குறிப்பிடப்படுகின்றன.

எடுத்துக்காட்டாக, [`ADD`](https://www.evm.codes/#01) செயல்பாட்டுக் குறியீட்டைப் பார்ப்போம்.

| மதிப்பு | நினைவூட்டி | δ   | α   | விளக்கம்                                               |
| ----: | -------- | --- | --- | --------------------------------------------------------- |
|  0x01 | ADD      | 2   | 1   | கூட்டல் செயல்பாடு.                                       |
|       |          |     |     | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[0] + μ<sub>s</sub>[1]_ |

_δ_ என்பது ஸ்டாக்கிலிருந்து நாம் வெளியேற்றும் மதிப்புகளின் எண்ணிக்கையாகும். இந்த நிலையில் இரண்டு, ஏனெனில் நாம் மேலிருக்கும் இரண்டு மதிப்புகளைக் கூட்டுகிறோம்.

_α_ என்பது நாம் மீண்டும் உள்ளே தள்ளும் மதிப்புகளின் எண்ணிக்கையாகும். இந்த நிலையில் ஒன்று, அதாவது கூடுதல்.

எனவே புதிய ஸ்டாக்கின் மேற்பகுதி (_μ′<sub>s</sub>[0]_) என்பது பழைய ஸ்டாக்கின் மேற்பகுதி (_μ<sub>s</sub>[0]_) மற்றும் அதற்குக் கீழே உள்ள பழைய மதிப்பு (_μ<sub>s</sub>[1]_) ஆகியவற்றின் கூடுதலாகும்.

அனைத்து செயல்பாட்டுக் குறியீடுகளையும் ஒரு சலிப்பான பட்டியலாகப் பார்ப்பதற்குப் பதிலாக, புதிதாக ஒன்றை அறிமுகப்படுத்தும் செயல்பாட்டுக் குறியீடுகளை மட்டுமே இந்தக் கட்டுரை விளக்குகிறது.

| மதிப்பு | நினைவூட்டி  | δ   | α   | விளக்கம்                                                                                                |
| ----: | --------- | --- | --- | ---------------------------------------------------------------------------------------------------------- |
|  0x20 | KECCAK256 | 2   | 1   | கெக்காக்-256 ஹாஷைக் கணக்கிடுதல்.                                                                                   |
|       |           |     |     | _μ′<sub>s</sub>[0] ≡ KEC(μ<sub>m</sub>[μ<sub>s</sub>[0] . . . (μ<sub>s</sub>[0] + μ<sub>s</sub>[1] − 1)])_ |
|       |           |     |     | _μ′<sub>i</sub> ≡ M(μ<sub>i</sub>,μ<sub>s</sub>[0],μ<sub>s</sub>[1])_                                      |

நினைவகத்தை அணுகும் முதல் செயல்பாட்டுக் குறியீடு இதுவாகும் (இந்த நிலையில், படிக்க-மட்டுமே). இருப்பினும், இது நினைவகத்தின் தற்போதைய வரம்புகளுக்கு அப்பால் விரிவடையக்கூடும், எனவே நாம் _μ<sub>i</sub>_ ஐப் புதுப்பிக்க வேண்டும். பக்கம் 30-இல் உள்ள சமன்பாடு 330-இல் வரையறுக்கப்பட்டுள்ள _M_ சார்பைப் பயன்படுத்தி இதைச் செய்கிறோம்.

| மதிப்பு | நினைவூட்டி | δ   | α   | விளக்கம்                       |
| ----: | -------- | --- | --- | --------------------------------- |
|  0x31 | BALANCE  | 1   | 1   | கொடுக்கப்பட்ட கணக்கின் இருப்பைப் பெறுதல். |
|       |          |     |     | ...                               |

நாம் இருப்பைக் கண்டறிய வேண்டிய முகவரி _μ<sub>s</sub>[0] mod 2<sup>160</sup>_ ஆகும். ஸ்டாக்கின் மேற்பகுதி முகவரியாகும், ஆனால் முகவரிகள் 160 பிட்கள் மட்டுமே என்பதால், நாம் 2<sup>160</sup> [மாடுலோ (modulo)](https://en.wikipedia.org/wiki/Modulo_operation) மதிப்பைக் கணக்கிடுகிறோம்.

_σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] ≠ ∅_ ஆக இருந்தால், இந்த முகவரியைப் பற்றிய தகவல் உள்ளது என்று அர்த்தம். அந்த நிலையில், _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>]<sub>b</sub>_ என்பது அந்த முகவரிக்கான இருப்பாகும். _σ[μ<sub>s</sub>[0] mod 2<sup>160</sup>] = ∅_ ஆக இருந்தால், இந்த முகவரி தொடங்கப்படவில்லை என்றும் இருப்பு பூஜ்ஜியம் என்றும் அர்த்தம். பக்கம் 4-இல் உள்ள பிரிவு 4.1-இல் கணக்குத் தகவல் புலங்களின் பட்டியலை நீங்கள் காணலாம்.

இரண்டாவது சமன்பாடான _A'<sub>a</sub> ≡ A<sub>a</sub> ∪ \{μ<sub>s</sub>[0] mod 2<sup>160</sup>}_ என்பது, வார்ம் சேமிப்பகத்தை (சமீபத்தில் அணுகப்பட்ட மற்றும் தற்காலிகமாகச் சேமிக்கப்பட்டிருக்கக்கூடிய சேமிப்பகம்) அணுகுவதற்கும் கோல்ட் சேமிப்பகத்தை (அணுகப்படாத மற்றும் மீட்டெடுக்க அதிக செலவாகும் மெதுவான சேமிப்பகத்தில் இருக்கக்கூடிய சேமிப்பகம்) அணுகுவதற்கும் இடையிலான செலவு வேறுபாட்டுடன் தொடர்புடையது. _A<sub>a</sub>_ என்பது பரிவர்த்தனையால் முன்பு அணுகப்பட்ட முகவரிகளின் பட்டியலாகும், எனவே பக்கம் 9-இல் உள்ள பிரிவு 6.1-இல் வரையறுக்கப்பட்டுள்ளபடி, இதை அணுகுவது மலிவானதாக இருக்க வேண்டும். இந்தத் தலைப்பைப் பற்றி [EIP-2929](https://eips.ethereum.org/EIPS/eip-2929)-இல் நீங்கள் மேலும் படிக்கலாம்.

| மதிப்பு | நினைவூட்டி | δ   | α   | விளக்கம்                             |
| ----: | -------- | --- | --- | --------------------------------------- |
|  0x8F | DUP16    | 16  | 17  | 16-ஆவது ஸ்டாக் உருப்படியை நகலெடுத்தல்.              |
|       |          |     |     | _μ′<sub>s</sub>[0] ≡ μ<sub>s</sub>[15]_ |

எந்தவொரு ஸ்டாக் உருப்படியையும் பயன்படுத்த, நாம் அதை வெளியேற்ற வேண்டும் என்பதைக் கவனியுங்கள், அதாவது அதன் மேல் உள்ள அனைத்து ஸ்டாக் உருப்படிகளையும் நாம் வெளியேற்ற வேண்டும். [`DUP<n>`](https://www.evm.codes/#8f) மற்றும் [`SWAP<n>`](https://www.evm.codes/#9f) ஆகியவற்றின் விஷயத்தில், பதினாறு மதிப்புகள் வரை வெளியேற்றிவிட்டு மீண்டும் உள்ளே தள்ள வேண்டும் என்று அர்த்தம்.
## 9.5 செயலாக்கச் சுழற்சி

இப்போது நம்மிடம் அனைத்துப் பகுதிகளும் இருப்பதால், EVM-இன் செயலாக்கச் சுழற்சி எவ்வாறு ஆவணப்படுத்தப்பட்டுள்ளது என்பதை நாம் இறுதியாகப் புரிந்துகொள்ளலாம்.

சமன்பாடு (164) கொடுக்கப்பட்ட நிலையைக் கூறுகிறது:

- _σ_ (உலகளாவிய தொகுதிச்சங்கிலி நிலை)
- _μ_ (EVM நிலை)
- _A_ (துணைநிலை, பரிவர்த்தனை முடிவடையும்போது நிகழ வேண்டிய மாற்றங்கள்)
- _I_ (செயலாக்கச் சூழல்)

புதிய நிலை _(σ', μ', A', I')_ ஆகும்.

சமன்பாடுகள் (165)-(167) ஸ்டாக்கையும், ஒரு செயல்பாட்டுக் குறியீட்டால் (_μ<sub>s</sub>_) அதில் ஏற்படும் மாற்றத்தையும் வரையறுக்கின்றன. சமன்பாடு (168) என்பது எரிவாயுவில் ஏற்படும் மாற்றமாகும் (_μ<sub>g</sub>_). சமன்பாடு (169) என்பது நிரல் கவுண்டரில் (program counter) ஏற்படும் மாற்றமாகும் (_μ<sub>pc</sub>_). இறுதியாக, சமன்பாடுகள் (170)-(173) செயல்பாட்டுக் குறியீட்டால் வெளிப்படையாக மாற்றப்படாவிட்டால், பிற அளவுருக்கள் அப்படியே இருக்கும் என்பதைக் குறிப்பிடுகின்றன.

இதன் மூலம் EVM முழுமையாக வரையறுக்கப்படுகிறது.
## முடிவுரை {#conclusion}

கணிதக் குறியீடு துல்லியமானது மற்றும் எத்திரியத்தின் ஒவ்வொரு விவரத்தையும் குறிப்பிட மஞ்சள் அறிக்கையை அனுமதித்துள்ளது. இருப்பினும், இதில் சில குறைபாடுகள் உள்ளன:

- இதை மனிதர்களால் மட்டுமே புரிந்துகொள்ள முடியும், அதாவது [இணக்கச் சோதனைகள் (compliance tests)](https://github.com/ethereum/tests) கைமுறையாக எழுதப்பட வேண்டும்.
- நிரலாளர்கள் கணினிக் குறியீட்டைப் புரிந்துகொள்கிறார்கள்.
  அவர்கள் கணிதக் குறியீட்டைப் புரிந்துகொள்ளலாம் அல்லது புரிந்துகொள்ளாமலும் இருக்கலாம்.

ஒருவேளை இந்தக் காரணங்களுக்காக, புதிய [கருத்தொருமிப்பு அடுக்கு விவரக்குறிப்புகள்](https://github.com/ethereum/consensus-specs/blob/master/tests/core/pyspec/README.md) Python-இல் எழுதப்பட்டிருக்கலாம். [Python-இல் செயலாக்க அடுக்கு விவரக்குறிப்புகள்](https://ethereum.github.io/execution-specs) உள்ளன, ஆனால் அவை முழுமையடையவில்லை. முழு மஞ்சள் அறிக்கையும் Python அல்லது அதைப் போன்ற ஒரு மொழிக்கு மொழிபெயர்க்கப்படும் வரை, மஞ்சள் அறிக்கை தொடர்ந்து சேவையில் இருக்கும், மேலும் அதைப் படிக்க முடிவது உதவியாக இருக்கும்.