Permission is granted to copy, distribute and/or modify this document.

ഈ ഡോക്യുമെന്റ് പകർത്തി വിതരണം ചെയ്യാനും കൂടാതെ/അല്ലെങ്കിൽ മാറ്റം വരുത്താനും അനുമതിയുണ്ട്.


The problems with concurrent programming are complex.

സമാന്തര പ്രോഗ്രാമിംഗിലെ പ്രശ്നങ്ങൾ സങ്കീർണ്ണമാണ്.


Hello World! is a classic introductory program.

ഹലോ വേൾഡ്! ഒരു ക്ലാസിക് പ്രാരംഭ പ്രോഗ്രാമാണ്.


Critical sections require careful management to avoid errors.

പിശകുകൾ ഒഴിവാക്കാൻ നിർണായക ഭാഗങ്ങൾ ശ്രദ്ധാപൂർവ്വം കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്.


The Harmony Virtual Machine is used for concurrent programming.

സമാന്തര പ്രോഗ്രാമിംഗിനായി ഹാർമണി വിർച്വൽ മെഷീൻ ഉപയോഗിക്കുന്നു.


Understanding concurrency is essential for modern software development.

ആധുനിക സോഫ്റ്റ്‌വെയർ വികസനത്തിന് കൺകറൻസി മനസ്സിലാക്കുന്നത് അത്യാവശ്യമാണ്.


Testing concurrent programs can be challenging.

സമാന്തര പ്രോഗ്രാമുകൾ പരീക്ഷിക്കുന്നത് വെല്ലുവിളിയാണ്.


Debugging concurrent code requires specialized tools.

സമാന്തര കോഡ് ഡീബഗ്ഗിംഗിന് പ്രത്യേക ഉപകരണങ്ങൾ ആവശ്യമാണ്.


Condition variables are used for thread synchronization.

ത്രെഡ് സമന്വയത്തിനായി കണ്ടീഷൻ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു.


Starvation can occur in concurrent systems.

സമാന്തര സിസ്റ്റങ്ങളിൽ വിശപ്പ് സംഭവിക്കാം.


Deadlock is a serious problem in concurrent programming.

സമാന്തര പ്രോഗ്രാമിംഗിലെ ഒരു ഗുരുതരമായ പ്രശ്നമാണ് ഡെഡ്‌ലോക്ക്.


Actors and message passing provide a different approach to concurrency.

നടൻമാരും സന്ദേശ കൈമാറ്റവും കൺകറൻസിക്ക് വ്യത്യസ്തമായ സമീപനം നൽകുന്നു.


Barrier synchronization is used to coordinate threads.

ത്രെഡുകളെ ഏകോപിപ്പിക്കാൻ തടസ്സ സമന്വയം ഉപയോഗിക്കുന്നു.


Advanced barrier synchronization techniques exist.

വിപുലമായ തടസ്സ സമന്വയ സാങ്കേതിക വിദ്യകൾ നിലവിലുണ്ട്.


A concurrent file service can improve performance.

ഒരു സമാന്തര ഫയൽ സേവനത്തിന് പ്രകടനം മെച്ചപ്പെടുത്താൻ കഴിയും.


Interrupts can complicate concurrent programming.

തടസ്സങ്ങൾ സമാന്തര പ്രോഗ്രാമിംഗിനെ സങ്കീർണ്ണമാക്കും.


Non-blocking synchronization is an alternative to locks.

നോൺ-ബ്ലോക്കിംഗ് സമന്വയം ലോക്കുകൾക്ക് ഒരു ബദലാണ്.


The Alternating Bit Protocol is a reliable data transfer protocol.

ആൾട്ടർനേറ്റിംഗ് ബിറ്റ് പ്രോട്ടോക്കോൾ ഒരു വിശ്വസനീയമായ ഡാറ്റാ കൈമാറ്റ പ്രോട്ടോക്കോൾ ആണ്.


Leader election is a fundamental problem in distributed systems.

ലീഡർ തിരഞ്ഞെടുപ്പ് വിതരണം ചെയ്ത സിസ്റ്റങ്ങളിലെ ഒരു അടിസ്ഥാന പ്രശ്നമാണ്.


Transactions and two-phase commit ensure data consistency.

ഇടപാടുകളും രണ്ട്-ഘട്ട പ്രതിബദ്ധതയും ഡാറ്റയുടെ സ്ഥിരത ഉറപ്പാക്കുന്നു.


The program demonstrates the basic concepts of concurrent programming.

സമാന്തര പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാന ആശയങ്ങൾ ഈ പ്രോഗ്രാം വ്യക്തമാക്കുന്നു.


Harmony programs are not intended to be 'run' like programs in most other programming languages.

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ പ്രോഗ്രാമുകൾ പോലെ പ്രവർത്തിപ്പിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല ഹാർമണി പ്രോഗ്രാമുകൾ.


The output is a Deterministic State Machine (DFA).

ഔട്ട്‌പുട്ട് ഒരു ഡിറ്റർമിനിസ്റ്റിക് സ്റ്റേറ്റ് മെഷീൻ (DFA) ആണ്.


In this case, the program chooses to print either 'hello' or 'world'.

ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാം 'ഹലോ' അല്ലെങ്കിൽ 'വേൾഡ്' പ്രിന്റ് ചെയ്യാൻ തിരഞ്ഞെടുക്കുന്നു.


Harmony usually requires that any program must be able to terminate.

ഏത് പ്രോഗ്രാമിനും അവസാനിപ്പിക്കാൻ കഴിയണമെന്ന് ഹാർമണി സാധാരണയായി ആവശ്യപ്പെടുന്നു.


Figure 2.4 demonstrates methods and threads in Harmony.

ചിത്രം 2.4 ഹാർമണിയിലെ രീതികളും ത്രെഡുകളും വ്യക്തമാക്കുന്നു.


Because the threads run concurrently, the program can either output 'hello world' or 'world hello'.

ത്രെഡുകൾ ഒരേസമയം പ്രവർത്തിക്കുന്നതിനാൽ, പ്രോഗ്രാമിന് 'ഹലോ വേൾഡ്' അല്ലെങ്കിൽ 'വേൾഡ് ഹലോ' ഔട്ട്‌പുട്ട് ചെയ്യാൻ കഴിയും.


Harmony is a programming language that borrows much of Python’s syntax.

ഹാർമണി, പൈത്തണിന്റെ പല ശൈലികളും കടമെടുത്ത ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയാണ്.


Harmony does not support floating point.

ഹാർമണി ഫ്ലോട്ടിംഗ് പോയിന്റിനെ പിന്തുണക്കുന്നില്ല.


In Python, lists, dictionaries, and sets are (mutable) objects. In Harmony, they are (immutable) values.

പൈത്തണിൽ, ലിസ്റ്റുകൾ, നിഘണ്ടുക്കൾ, സെറ്റുകൾ എന്നിവ (മാറാൻ കഴിയുന്ന) ഒബ്ജക്റ്റുകളാണ്. ഹാർമണിയിൽ, അവ (മാറാൻ കഴിയാത്ത) മൂല്യങ്ങളാണ്.


The example is a sequential program and has a method triangle that takes an integer number as argument.

ഉദാഹരണത്തിൽ ഒരു സീക്വൻഷ്യൽ പ്രോഗ്രാമും, ഒരു പൂർണ്ണസംഖ്യയെ ആർഗ്യുമെന്റായി എടുക്കുന്ന ട്രയാംഗിൾ എന്ന രീതിയും ഉണ്ട്.


Running this Harmony program will try all possible executions.

ഈ ഹാർമണി പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നത് എല്ലാ സാധ്യതയുള്ള എക്സിക്യൂഷനുകളും ശ്രമിക്കും.


The assert statement checks that the output is correct.

ഔട്ട്‌പുട്ട് ശരിയാണോ എന്ന് അസേർട്ട് സ്റ്റേറ്റ്‌മെന്റ് പരിശോധിക്കുന്നു.


If the program is correct, Harmony reports the size of the 'state graph'.

പ്രോഗ്രാം ശരിയാണെങ്കിൽ, ഹാർമണി 'സ്റ്റേറ്റ് ഗ്രാഫിന്റെ' വലുപ്പം റിപ്പോർട്ട് ചെയ്യുന്നു.


Constants have a default specified value, but those can be overridden on the command line.

സ്ഥിരമായ മൂല്യങ്ങൾക്ക് ഒരു നിർദ്ദിഷ്ട മൂല്യം ഉണ്ട്, എന്നാൽ കമാൻഡ് ലൈനിൽ ഇത് മാറ്റിയെഴുതാൻ കഴിയും.


Concurrent programming involves multiple threads running in parallel while sharing variables.

സമാന്തര പ്രോഗ്രാമിംഗിൽ ഒന്നിലധികം ത്രെഡുകൾ വേരിയബിളുകൾ പങ്കുവെച്ച് സമാന്തരമായി പ്രവർത്തിക്കുന്നു.


This problem is an example of non-determinism.

ഈ പ്രശ്നം നിർണ്ണായകമല്ലാത്തതിന്റെ ഒരു ഉദാഹരണമാണ്.


Methods f() and g() can run in either order.

രീതികളായ f() g() എന്നിവ ഏത് ക്രമത്തിലും പ്രവർത്തിക്കാൻ സാധ്യതയുണ്ട്.


The Harmony finally statement is similar to an assert statement.

ഹാർമണി ഫൈനലി സ്റ്റേറ്റ്‌മെന്റ്, ഒരു അസേർട്ട് സ്റ്റേറ്റ്‌മെന്റിന് സമാനമാണ്.


The lack of determinism and atomicity in concurrent programs make them hard to test.

സമാന്തര പ്രോഗ്രാമുകളിലെ നിർണ്ണായകത്വത്തിന്റെയും ആറ്റോമിസിറ്റിയുടെയും അഭാവം അവയെ പരീക്ഷിക്കാൻ പ്രയാസകരമാക്കുന്നു.


The code prevents multiple threads from executing in the critical section at the same time.

ഈ കോഡ് ഒരേ സമയം ഒന്നിലധികം ത്രെഡുകൾ ക്രിട്ടിക്കൽ വിഭാഗത്തിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നത് തടയുന്നു.


Mutual exclusion is a safety property that ensures nothing bad will happen.

പരസ്പര ഒഴിവാക്കൽ എന്നത് ഒരു സുരക്ഷാ സ്വത്താണ്, അത് മോശമായതൊന്നും സംഭവിക്കില്ലെന്ന് ഉറപ്പാക്കുന്നു.


We want to ensure that eventually something good will happen.

അവസാനം നല്ലൊന്ന് സംഭവിക്കുമെന്ന് ഞങ്ങൾ ഉറപ്പാക്കാൻ ആഗ്രഹിക്കുന്നു.


If threads in the critical section always leave eventually, then eventually one thread will enter the critical section.

നിർണായകമായ ഭാഗത്തുള്ള ത്രെഡുകൾ എപ്പോഴും പുറത്ത് പോവുകയാണെങ്കിൽ, ഒടുവിൽ ഒരു ത്രെഡ് നിർണായക ഭാഗത്തേക്ക് പ്രവേശിക്കും.


Harmony requires that every execution must be able to reach a state in which all threads have terminated.

എല്ലാ എക്സിക്യൂഷനും എല്ലാ ത്രെഡുകളും അവസാനിപ്പിച്ച ഒരു അവസ്ഥയിലെത്താൻ കഴിയണമെന്ന് ഹാർമണി ആവശ്യപ്പെടുന്നു.


A thread can choose to enter a critical section more than once.

ഒരു ത്രെഡിന് ഒന്നിലധികം തവണ ഒരു നിർണായക ഭാഗത്തേക്ക് പ്രവേശിക്കാൻ തിരഞ്ഞെടുക്കാം.


We also test if a thread can enter when there is no other thread trying to enter the critical section.

മറ്റൊരു ത്രെഡും ക്രിട്ടിക്കൽ ഭാഗത്തേക്ക് പ്രവേശിക്കാൻ ശ്രമിക്കാത്തപ്പോൾ ഒരു ത്രെഡിന് പ്രവേശിക്കാൻ കഴിയുമോ എന്നും ഞങ്ങൾ പരിശോധിക്കുന്നു.


This code specifies that at most one thread can be executing in the critical section.

ഈ കോഡ്, ക്രിട്ടിക്കൽ വിഭാഗത്തിൽ പരമാവധി ഒരു ത്രെഡിന് പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് വ്യക്തമാക്കുന്നു.


You may already have heard of the concept of a lock.

നിങ്ങൾ ഇതിനകം തന്നെ ഒരു ലോക്ക് എന്ന ആശയം കേട്ടിരിക്കാം.


The idea is that the lock is like a baton that at most one thread can own.

ലോക്ക് എന്നത് ഒരു ബാറ്റൺ പോലെയാണ്, പരമാവധി ഒരു ത്രെഡിന് സ്വന്തമാക്കാൻ കഴിയും.


A thread that wants to enter the critical section must obtain the lock first.

ക്രിട്ടിക്കൽ ഭാഗത്തേക്ക് പ്രവേശിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരു ത്രെഡ് ആദ്യം ലോക്ക് നേടണം.


Figure 5.3 presents an attempt at mutual exclusion based on a naive implementation of a lock.

ഒരു ലോക്കിൻ്റെ നിഷ്കളങ്കമായ നടപ്പാതയെ അടിസ്ഥാനമാക്കി പരസ്പര ഒഴിവാക്കാനുള്ള ഒരു ശ്രമമാണ് ചിത്രം 5.3-ൽ അവതരിപ്പിക്കുന്നത്.


The lockTaken variable suffers from the same sort of race condition.

lockTaken എന്ന വേരിയബിളിന് അതേ ರೀತಿಯ റേസ് അവസ്ഥയുണ്ട്.


Preventing multiple threads from updating the same variable.

ഒരേ വേരിയബിൾ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിൽ നിന്ന് ഒന്നിലധികം ത്രെഡുകളെ തടയുന്നു.


A thread can write its own flag and read the flag of its peer.

ഒരു ത്രെഡിന് അതിൻ്റേതായ ഫ്ലാഗ് എഴുതാനും അതിൻ്റെ പിയറിൻ്റെ ഫ്ലാഗ് വായിക്കാനും കഴിയും.


If thread i is in the critical section, then flags[i] = True.

ത്രെഡ് i നിർണായക ഭാഗത്താണെങ്കിൽ, flags[i] = ശരി.


Each thread politely lets the other thread have a turn first.

ഓരോ ത്രെഡും സൗമ്യമായി മറ്റ് ത്രെഡിനെ ആദ്യം അവസരം നൽകുന്നു.


The algorithm is an amalgam of the incorrect algorithms.

ഈ അൽഗോരിതം തെറ്റായ അൽഗോരിതങ്ങളുടെ ഒരു സംയോജനമാണ്.


Peterson’s algorithm implements a critical section, but it is not efficient.

Peterson-ൻ്റെ അൽഗോരിതം ഒരു നിർണായക ഭാഗം നടപ്പിലാക്കുന്നു, എന്നാൽ ഇത് കാര്യക്ഷമമല്ല.


Modern processors sometimes re-orders load and store operations.

ആധുനിക പ്രോസസ്സറുകൾ ചിലപ്പോൾ ലോഡ്, സ്റ്റോർ പ്രവർത്തനങ്ങൾ വീണ്ടും ഓർഡർ ചെയ്യുന്നു.


The program uses N+ 1 boolean variables.

പ്രോഗ്രാം N+ 1 boolean വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു.


In Harmony, any statement can be preceded by the atomically keyword.

ഹാർമണിയിൽ, ഏതൊരു പ്രസ്താവനയും ആറ്റോമികമായി കീവേഡിന് മുന്നിൽ വരാം.


The code in Figure 7.1 also uses the Harmony when statement.

ചിത്രം 7.1-ലെ കോഡും ഹാർമണിയിലെ 'when' പ്രസ്താവന ഉപയോഗിക്കുന്നു.


Locks are the most prevalent and basic form of synchronization in concurrent programs.

സമാന്തര പ്രോഗ്രാമുകളിൽ സമന്വയത്തിന്റെ ഏറ്റവും സാധാരണവും അടിസ്ഥാനപരവുമായ രൂപമാണ് ലോക്കുകൾ.


A data race happens when there is a state in which multiple threads are trying to access the same variable.

ഒരേ വേരിയബിളിലേക്ക് ഒന്നിലധികം ത്രെഡുകൾ ആക്സസ് ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഒരു ഡാറ്റാ റേസ് സംഭവിക്കുന്നു.


In Harmony, this can be done in two ways.

ഹാർമണിയിൽ, ഇത് രണ്ട് രീതിയിൽ ചെയ്യാവുന്നതാണ്.


To implement locks, multi-core processors provide so-called atomic instructions.

ലോക്കുകൾ നടപ്പിലാക്കാൻ, മൾട്ടി-കോർ പ്രോസസ്സറുകൾ ആറ്റോമിക് നിർദ്ദേശങ്ങൾ നൽകുന്നു.


Method swap in Figure 8.1 shows its specification.

ചിത്രം 8.1-ൽ, സ്വാപ്പ് രീതി അതിന്റെ സ്പെസിഫിക്കേഷൻ കാണിക്കുന്നു.


The approach is called spinlock, because each thread is “spinning” until it can acquire the lock.

ഓരോ ത്രെഡും ലോക്ക് നേടുന്നതുവരെ


An important invariant, I1, of the program is that at any time exactly one of these variables is False.

പ്രധാനപ്പെട്ട ഒരു ഇൻവേരിയന്റ്, I1, പ്രോഗ്രാമിന്റെ ഏതെങ്കിലും സമയത്ത് ഈ വേരിയബിളുകളിൽ ഒന്ന് കൃത്യമായി തെറ്റാണ്.


Method test and set involves only a single variable.

ടെസ്റ്റ് ആൻഡ് സെറ്റ് രീതിയിൽ ഒരു വേരിയബിൾ മാത്രമേ ഉൾപ്പെടുന്നുള്ളൂ.


The variable represents the lock: If free, the value is False; if taken, the value is True.

വേരിയബിൾ ലോക്കിനെ പ്രതിനിധീകരിക്കുന്നു: ഫ്രീ ആണെങ്കിൽ, മൂല്യം തെറ്റാണ്; എടുത്താൽ, മൂല്യം ശരിയാണ്.


Besides this solution being more efficient than Figure 8.1, the solution is general for any number of threads.

ചിത്രം 8.1 നെക്കാൾ ഈ പരിഹാരം കൂടുതൽ കാര്യക്ഷമമാണ്, കൂടാതെ ഈ പരിഹാരം ഏത് എണ്ണം ത്രെഡുകൾക്കും പൊതുവായി ഉപയോഗിക്കാം.


A ticket lock is an implementation of a lock that prevents starvation using an atomic fetch-and-increment operator.

ഒരു ടിക്കറ്റ് ലോക്ക് എന്നത് ഒരു ആറ്റോമിക് ഫെച്ച്-ആൻഡ്-ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്റർ ഉപയോഗിച്ച് വിശപ്പ് തടയുന്ന ഒരു ലോക്കിൻ്റെ നടപ്പാക്കലാണ്.


When a thread tries to acquire the lock, it first fetches the current value of the dispenser variable.

ഒരു ത്രെഡ് ലോക്ക് നേടാൻ ശ്രമിക്കുമ്പോൾ, അത് ആദ്യം ഡിസ്പെൻസർ വേരിയബിളിൻ്റെ നിലവിലെ മൂല്യം എടുക്കുന്നു.


We now turn to a radically different way of implementing locks.

ഇനി നമുക്ക് ലോക്കുകൾ നടപ്പിലാക്കുന്നതിൻ്റെ വ്യത്യസ്തമായ രീതിയിലേക്ക് കടക്കാം.


A thread trying to acquire a lock held by another thread is a good example of a thread being blocked.

മറ്റൊരു ത്രെഡ് കൈവശം വെച്ചിരിക്കുന്ന ഒരു ലോക്ക് നേടാൻ ശ്രമിക്കുന്ന ഒരു ത്രെഡ്, ബ്ലോക്ക് ചെയ്യപ്പെടുന്ന ഒരു ത്രെഡിന് നല്ല ഉദാഹരണമാണ്.


In Harmony, a thread can suspend itself and save its context (state) in a shared variable.

ഹാർമണിയിൽ, ഒരു ത്രെഡിന് സ്വയം സസ്പെൻഡ് ചെയ്യാനും അതിൻ്റെ സന്ദർഭം (സ്ഥിതി) ഒരു പങ്കിട്ട വേരിയബിളിൽ സംരക്ഷിക്കാനും കഴിയും.


The expression causes the context of the thread to be saved in !s and the thread to be no longer running.

ഈ എക്സ്പ്രഷൻ ത്രെഡിൻ്റെ സന്ദർഭം !s-ൽ സംരക്ഷിക്കാനും ത്രെഡ് ഇനി പ്രവർത്തിക്കാതിരിക്കാനും കാരണമാകുന്നു.


Sequential specifications are useful to write down.

തുടർച്ചയായ സ്പെസിഫിക്കേഷനുകൾ എഴുതാൻ ഉപയോഗപ്രദമാണ്.


The machine does not have instructions to atomically increment or decrement values in shared memory locations.

മെഷീന് പൊതുവായ മെമ്മറി സ്ഥാനങ്ങളിൽ മൂല്യങ്ങൾ ആറ്റോമികമായി വർദ്ധിപ്പിക്കാനോ കുറയ്ക്കാനോ നിർദ്ദേശങ്ങളില്ല.


When running multiple threads, each essentially runs an instantiation of the machine, and they do so in parallel.

ഒന്നിലധികം ത്രെഡുകൾ പ്രവർത്തിക്കുമ്പോൾ, ഓരോന്നും അടിസ്ഥാനപരമായി മെഷീന്റെ ഒരു ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നു, കൂടാതെ അവ സമാന്തരമായി പ്രവർത്തിക്കുന്നു.


A program is correct if it works for all possible interleavings of threads.

എല്ലാ സാധ്യതയുള്ള ത്രെഡുകളുടെ ഇടപെടലുകൾക്കും ഒരു പ്രോഗ്രാം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ അത് ശരിയാണ്.


Harmony will try all interleavings and report an error even if only one of those interleavings fails.

എല്ലാ ഇടപെടലുകളും Harmony ശ്രമിക്കും, കൂടാതെ ആ ഇടപെടലുകളിൽ ഒന്ന് പരാജയപ്പെട്ടാലും ഒരു പിശക് റിപ്പോർട്ട് ചെയ്യും.


ഇതൊരു റേസ് അവസ്ഥയായി അറിയപ്പെടുന്നു.


When running a program with Harmony, it will report violations of assertions.

Harmony ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ഉറപ്പുകളുടെ ലംഘനങ്ങൾ റിപ്പോർട്ട് ചെയ്യും.


If one thinks of the assertion as providing the specification of the program, then clearly its implementation does not satisfy its specification.

പ്രോഗ്രാമിന്റെ സ്പെസിഫിക്കേഷൻ നൽകുന്ന ഒന്നായി ഈ ഉറപ്പിനെ കണക്കാക്കിയാൽ, അതിന്റെ നടപ്പാക്കൽ അതിന്റെ സ്പെസിഫിക്കേഷൻ തൃപ്തികരമല്ലാത്തതാണെന്ന് വ്യക്തമാണ്.


We could change the specification by changing the assertion as follows: finally(x== 1)or(x== 2)

ഇനി പറയുന്ന രീതിയിൽ ഉറപ്പ് മാറ്റുന്നതിലൂടെ നമുക്ക് സ്പെസിഫിക്കേഷൻ മാറ്റാൻ കഴിയും: അവസാനം(x== 1) അല്ലെങ്കിൽ(x== 2)


The exercises below have you try the same thing (having threads concurrently increment an integer variable) in Python.

താഴെയുള്ള വ്യായാമങ്ങൾ, ഒരേ കാര്യം പൈത്തണിൽ പരീക്ഷിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു (ത്രെഡുകൾ ഒരേസമയം ഒരു പൂർണ്ണസംഖ്യാ വേരിയബിൾ വർദ്ധിപ്പിക്കുന്നു).


Run Figure 3.4 using Python. Does the assertion fail?

പൈത്തൺ ഉപയോഗിച്ച് ചിത്രം 3.4 പ്രവർത്തിപ്പിക്കുക. ഈ ഉറപ്പ് പരാജയപ്പെടുന്നുണ്ടോ?


Using a script, run Figure 3.4 1000 times.

ഒരു സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച്, ചിത്രം 3.4 1000 തവണ പ്രവർത്തിപ്പിക്കുക.


How many times does the assertion fail (if any)?

എത്ര തവണ ഈ ഉറപ്പ് പരാജയപ്പെടുന്നു (എന്തെങ്കിലും ഉണ്ടെങ്കിൽ)?


Figure 3.5 is a version of Figure 3.4 that has each thread increment x N times.

ചിത്രം 3.5, ഓരോ ത്രെഡും x N തവണ വർദ്ധിപ്പിക്കുന്ന ചിത്രം 3.4-ന്റെ ഒരു പതിപ്പാണ്.


Report how many times the assertion fails and what the value of x was for each of the failed runs.

എത്ര തവണ ഈ ഉറപ്പ് പരാജയപ്പെട്ടുവെന്നും, പരാജയപ്പെട്ട ഓരോ റണ്ണിനും x-ന്റെ മൂല്യം എന്തായിരുന്നു എന്നും റിപ്പോർട്ട് ചെയ്യുക.


Also experiment with other values of N. How large does N need to be for assertions to fail?

N-ന്റെ മറ്റ് മൂല്യങ്ങൾ ഉപയോഗിച്ച് പരീക്ഷണം നടത്തുക. ഉറപ്പുകൾ പരാജയപ്പെടുന്നതിന് N എത്ര വലുതായിരിക്കണം?


Harmony programs, and indeed the HVM, manipulate Harmony values.

Harmony പ്രോഗ്രാമുകളും, വാസ്തവത്തിൽ HVM-ഉം, Harmony മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.


Strings that start with a letter or an underscore and only contain letters, digits, and underscores can be written without quotes by preceding them with a dot.

അക്ഷരത്തിലോ, അടിവരയിലോ ആരംഭിച്ച് അക്ഷരങ്ങളും, അക്കങ്ങളും, അടിവരകളും മാത്രം അടങ്ങിയ സ്ട്രിംഗുകൾ, ഒരു ഡോട്ട് ചേർത്ത് ഉദ്ധരണികൾ ഇല്ലാതെ എഴുതാം.


ഒരു നിഘണ്ടു താക്കോലുകളെ മൂല്യങ്ങളിലേക്ക് മാപ്പ് ചെയ്യുന്നു.


The shared memory is a dictionary that maps strings (names of shared variables) to other Harmony values.

പങ്കിട്ട മെമ്മറി എന്നത് സ്ട്രിംഗുകളെ (പങ്കിട്ട വേരിയബിളുകളുടെ പേരുകൾ) മറ്റ് Harmony മൂല്യങ്ങളിലേക്ക് മാപ്പ് ചെയ്യുന്ന ഒരു നിഘണ്ടുവാണ്.


Each thread in the HVM is predominantly a stack machine, but it also has a register that contains the values of the local variables of the method that the thread is currently executing.

HVM-ലെ ഓരോ ത്രെഡും പ്രധാനമായും ഒരു സ്റ്റാക്ക് മെഷീനാണ്, എന്നാൽ നിലവിൽ ത്രെഡ് എക്സിക്യൂട്ട് ചെയ്യുന്ന രീതിയുടെ പ്രാദേശിക വേരിയബിളുകളുടെ മൂല്യങ്ങൾ അടങ്ങിയ ഒരു രജിസ്റ്ററും ഇതിനുണ്ട്.


ഇന്ന് കാലാവസ്ഥ സുഖകരമാണ്.


അല്പം ഉപ്പ് തരുമോ?


ഞാൻ കച്ചവട സ്ഥലത്തേക്ക് പോകുന്നു.


കമ്പനി ഒരു പുതിയ ഉൽപ്പന്നം പ്രഖ്യാപിച്ചു.


അദ്ദേഹം വളരെ കഴിവുള്ള ഒരു സംഗീതജ്ഞനാണ്.


The research team published their findings.

ഗവേഷണ സംഘം അവരുടെ കണ്ടെത്തലുകൾ പ്രസിദ്ധീകരിച്ചു.


The algorithm efficiently sorts the data.

അൽഗോരിതം ഡാറ്റയെ കാര്യക്ഷമമായി അടുക്കുന്നു.


പ്രതിസന്ധികൾ ഉണ്ടായിട്ടും, അവർ വിജയിച്ചു.


നാളെ യോഗം നടക്കും.


അവൾക്ക് നിരവധി ഭാഷകളിൽ നല്ല പ്രാവീണ്യമുണ്ട്.


സാമ്പത്തിക പ്രവചനം നല്ല രീതിയിലാണ്.


The software update includes new features.

സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റിൽ പുതിയ ഫീച്ചറുകൾ ഉൾപ്പെടുന്നു.


അദ്ദേഹം തൻ്റെ നൂതന ആശയങ്ങൾക്ക് പേരുകേട്ടതാണ്.


പ്രോജക്റ്റിന് ശ്രദ്ധാപൂർവമായ ആസൂത്രണം ആവശ്യമാണ്.


The government implemented new policies.

സർക്കാർ പുതിയ നയങ്ങൾ നടപ്പാക്കി.


The company is expanding its operations globally.

കമ്പനി അതിന്റെ പ്രവർത്തനങ്ങൾ ലോകമെമ്പാടും വികസിപ്പിക്കുന്നു.


The complex system requires specialized knowledge.

സങ്കീർണ്ണമായ ഈ സിസ്റ്റത്തിന് പ്രത്യേക പരിജ്ഞാനം ആവശ്യമാണ്.


The implications of the decision are far-reaching.

തീരുമാനത്തിന്റെ അനന്തരഫലങ്ങൾ വളരെ ദൂരവ്യാപകമാണ്.


The scientific community is debating the findings.

ശാസ്ത്രജ്ഞർ ഈ കണ്ടെത്തലിനെക്കുറിച്ച് ചർച്ച ചെയ്യുന്നു.


ചർച്ചകൾ ഒരു പ്രതിസന്ധിയിലെത്തി.


The philosopher picks up the fork on the left, then the fork on the right.

തത്ത്വജ്ഞാനി ഇടത് വശത്തുള്ള ഫോർക്ക് എടുക്കുന്നു, തുടർന്ന് വലത് വശത്തുള്ള ഫോർക്ക് എടുക്കുന്നു.


Each philosopher requires two forks to eat.

ഓരോ തത്ത്വജ്ഞാനിക്കും ഭക്ഷണം കഴിക്കാൻ രണ്ട് ഫോർക്കുകൾ ആവശ്യമാണ്.


Dijkstra had them repeating this for ever.

ഡൈക്സ്ട്ര അവരെ ഇത് എന്നെന്നും ആവർത്തിക്കാൻ ഏൽപ്പിച്ചു.


If you run it, Harmony complains that the execution may not be able to terminate.

നിങ്ങൾ ഇത് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, എക്സിക്യൂഷൻ അവസാനിപ്പിക്കാൻ കഴിയില്ലെന്ന് ഹാർമണി പരാതിപ്പെടുന്നു.


Mutual Exclusion: each resource can only be used by one thread at a time.

പരസ്പര ഒഴിവാക്കൽ: ഓരോ resource-ഉം ഒരേ സമയം ഒരു thread-ന് മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ.


Preventing deadlock thus means preventing that one of these conditions occurs.

അതിനാൽ, ഡെഡ്‌ലോക്ക് തടയുക എന്നാൽ ഈ അവസ്ഥകളിലൊന്ന് സംഭവിക്കുന്നത് തടയുക എന്നാണ് അർത്ഥമാക്കുന്നത്.


Havender proposed the following techniques that avoid the remaining three conditions.

ബാക്കിയുള്ള മൂന്ന് നിബന്ധനകൾ ഒഴിവാക്കുന്ന താഴെ പറയുന്ന സാങ്കേതിക വിദ്യകൾ ഹാവെൻഡർ നിർദ്ദേശിച്ചു.


To implement a No Hold and Wait solution, a philosopher would need a way to lock both the left and right forks at the same time.

ഹോൾഡ് ആൻഡ് വെയിറ്റ് പരിഹാരം നടപ്പിലാക്കാൻ, തത്ത്വജ്ഞാനിക്ക് ഒരേ സമയം ഇടത്, വലത് ഫോർക്കുകൾ ലോക്ക് ചെയ്യാനുള്ള ഒരു വഴി ആവശ്യമാണ്.


ലോക്കുകൾക്ക് അത്തരം കഴിവില്ല.


The implementation uses a boolean for each fork indicating if the fork has been taken.

ഫോർക്ക് എടുത്തിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഓരോ ഫോർക്കിനും ഇത് ഒരു boolean ഉപയോഗിക്കുന്നു.


When a philosopher is done eating, it notifies both of its neighbors.

ഒരു തത്ത്വജ്ഞാനി ഭക്ഷണം കഴിച്ച് കഴിഞ്ഞാൽ, അത് ഇരുവശത്തുമുള്ള അയൽക്കാരെ അറിയിക്കുന്നു.


The No Circular Waiting approach is to prevent a cycle from forming.

ഒരു സർക്കിൾ രൂപീകരിക്കുന്നത് തടയുക എന്നതാണ് നോ സർക്കുലർ വെയിറ്റിംഗ് സമീപനം.


We can do this by establishing an ordering among the resources.

resource-കളുടെ ഇടയിൽ ഒരു ഓർഡർ സ്ഥാപിക്കുന്നതിലൂടെ ഇത് ചെയ്യാൻ കഴിയും.


They could prevent deadlock by always picking up the lower numbered fork before the higher numbered fork.

കൂടുതൽ സംഖ്യയുള്ള ഫോർക്കിന് മുൻപ് കുറഞ്ഞ സംഖ്യയുള്ള ഫോർക്ക് എടുക്കുന്നതിലൂടെ അവർക്ക് ഡെഡ്‌ലോക്ക് ഒഴിവാക്കാൻ കഴിയും.


This completes all the Havender methods.

ഇത് എല്ലാ ഹാവെൻഡർ രീതികളും പൂർത്തിയാക്കുന്നു.


There is, however, another approach, which is sometimes called deadlock avoidance instead of deadlock prevention.

എങ്കിലും, മറ്റൊരു സമീപനമുണ്ട്, ഇതിനെ ചിലപ്പോൾ ഡെഡ്‌ലോക്ക് പ്രിവൻഷനുപകരം ഡെഡ്‌ലോക്ക് ഒഴിവാക്കൽ എന്ന് വിളിക്കുന്നു.


If we can prevent more than four diners from starting to eat at the same time, then we can avoid the conditions for deadlock from ever happening.

നാലിൽ കൂടുതൽ ആളുകൾ ഒരേ സമയം ഭക്ഷണം കഴിക്കുന്നത് തടയാൻ കഴിഞ്ഞാൽ, ഡെഡ്‌ലോക്കിനായുള്ള സാഹചര്യങ്ങൾ ഉണ്ടാകുന്നത് നമുക്ക് ഒഴിവാക്കാം.


A counting semaphore is a resource that can be procured a given number of times.

ഒരു കൗണ്ടിംഗ് സെമാഫോർ എന്നത് ഒരു നിശ്ചിത എണ്ണം തവണ നേടാൻ കഴിയുന്ന ഒരു resource ആണ്.


The problem with these kinds of schemes is that one needs to know ahead of time the set of threads.

ഇത്തരം സ്കീമുകളുടെ പ്രശ്നം എന്തെന്നാൽ, ത്രെഡുകളുടെ സെറ്റ് മുൻകൂട്ടി അറിയേണ്ടതുണ്ട്.


Actors are threads that have only private memory and communicate through message passing.

ആക്ടർമാർക്ക് സ്വകാര്യ മെമ്മറിയും സന്ദേശങ്ങൾ കൈമാറുന്നതിലൂടെ ആശയവിനിമയവും ഉണ്ട്.


The thread T1 was trying to acquire a lock.

T1 എന്ന ത്രെഡ് ഒരു ലോക്ക് നേടാൻ ശ്രമിക്കുകയായിരുന്നു.


T3 removed the node that T1 was trying to access.

T1-ന് ആക്സസ് ചെയ്യാൻ ശ്രമിച്ച നോഡ് T3 നീക്കം ചെയ്തു.


Harmony allows you to step through an execution forwards and backwards.

ഒരു എക്സിക്യൂഷൻ മുന്നോട്ടും പിന്നോട്ടും കടന്നുപോകുവാൻ ഹാർമണി നിങ്ങളെ അനുവദിക്കുന്നു.


You can click its first (top-left) orange box to time-travel to that part in the execution.

നിങ്ങൾക്ക് അതിന്റെ ആദ്യത്തെ (മുകളിലെ ഇടത്) ഓറഞ്ച് ബോക്സിൽ ക്ലിക്ക് ചെയ്ത് എക്സിക്യൂഷനിലെ ആ ഭാഗത്തേക്ക് സമയയാത്ര ചെയ്യാം.


ഓരോ രീതിക്കും അതിൻ്റേതായ നിറമുണ്ട്.


T1 first calls put(?q, 1) and then allocates a new node initialized with a lock.

T1 ആദ്യം put(?q, 1) എന്ന് വിളിക്കുന്നു, തുടർന്ന് ഒരു ലോക്ക് ഉപയോഗിച്ച് ആരംഭിച്ച ഒരു പുതിയ നോഡ് അനുവദിക്കുന്നു.


T1 then enters into the while loop and tries to acquire nq→lock.

T1 തുടർന്ന് while ലൂപ്പിലേക്ക് പ്രവേശിക്കുകയും nq→lock നേടാൻ ശ്രമിക്കുകയും ചെയ്യുന്നു.


T3 chooses "get" and then goes on to invoke get(?q).

T3 "get" തിരഞ്ഞെടുക്കുകയും തുടർന്ന് get(?q) വിളിക്കുകയും ചെയ്യുന്നു.


This is where the problem is—T1 is about to acquire the lock in that same node.

ഇവിടെയാണ് പ്രശ്നം - T1 അതേ നോഡിലെ ലോക്ക് നേടാൻ പോകുന്നു.


To fix the code without changing the data structure, we can use hand-over-hand locking.

ഡാറ്റാ ഘടന മാറ്റാതെ കോഡ് ശരിയാക്കാൻ, നമുക്ക് കൈമാറ്റ ലോക്കിംഗ് ഉപയോഗിക്കാം.


Critical sections enable multiple threads to easily share data structures.

നിർണായക ഭാഗങ്ങൾ ഒന്നിലധികം ത്രെഡുകൾക്ക് ഡാറ്റാ ഘടനകൾ എളുപ്പത്തിൽ പങ്കിടാൻ സഹായിക്കുന്നു.


A thread that is waiting for a condition without changing shared variables is considered blocked.

പങ്കിട്ട വേരിയബിളുകൾ മാറ്റാതെ ഒരു അവസ്ഥയ്ക്കായി കാത്തിരിക്കുന്ന ഒരു ത്രെഡിനെ തടഞ്ഞതായി കണക്കാക്കുന്നു.


Sometimes it is useful for a thread to wait for additional conditions besides the critical section being unoccupied.

നിർണായക ഭാഗം ഒഴിഞ്ഞുകിടക്കുന്നതിനു പുറമേ, അധിക വ്യവസ്ഥകൾക്കായി ഒരു ത്രെഡ് കാത്തിരിക്കുന്നത് ചിലപ്പോൾ ഉപയോഗപ്രദമാണ്.


One important case is when multiple threads are simply reading the data structure.

ഒന്നിലധികം ത്രെഡുകൾ ഡാറ്റാ ഘടന വായിക്കുമ്പോൾ ഒരു പ്രധാന കാര്യമുണ്ട്.


What we want is a special kind of lock that allows either (i) one writer or (ii) one or more readers to acquire the lock.

ഒന്നുകിൽ (i) ഒരു എഴുത്തുകാരനോ അല്ലെങ്കിൽ (ii) ഒന്നോ അതിലധികമോ വായനക്കാരോ ലോക്ക് നേടാൻ അനുവദിക്കുന്ന ഒരു പ്രത്യേക തരം ലോക്കാണ് നമുക്ക് വേണ്ടത്.


A reader/writer lock is an object whose abstract state contains two integer counters.

ഒരു റീഡർ/റൈറ്റർ ലോക്ക് എന്നത് രണ്ട് പൂർണ്ണസംഖ്യാ കൗണ്ടറുകൾ അടങ്ങിയ ഒരു വസ്തുവാണ്.


Similar to ordinary locks, a thread is restricted in how it is allowed to invoke these operations.

സാധാരണ ലോക്കുകൾക്ക് സമാനമായി, ഈ പ്രവർത്തനങ്ങൾ എങ്ങനെ വിളിക്കാമെന്നതിന് ഒരു ത്രെഡിന് നിയന്ത്രണമുണ്ട്.


In some sense, the implementation is correct because it satisfies the invariant, but it is not a desirable implementation.

ചില അർത്ഥത്തിൽ, ഇത് ശരിയാണ്, കാരണം ഇത് ഇൻവേരിയന്റ് നിറവേറ്റുന്നു, പക്ഷേ ഇത് ആവശ്യമുള്ള നടപ്പാക്കലല്ല.


The second command will print a warning that there are behaviors in the specification that are not achieved by the implementation.

രണ്ടാമത്തെ കമാൻഡ്, നടപ്പാക്കുന്നതിലൂടെ നേടാനാകാത്ത സ്പെസിഫിക്കേഷനിൽ പെരുമാറ്റങ്ങളുണ്ടെന്ന് ഒരു മുന്നറിയിപ്പ് നൽകും.


Harmony can be particularly helpful here, as it examines each and every corner case.

ഓരോ കോണിലുള്ള കേസുകളും പരിശോധിക്കുന്നതിനാൽ, ഇവിടെ ഹാർമണിക്ക് പ്രത്യേകിച്ചും സഹായകമാകും.


That reliably sends messages between threads.

അത് ത്രെഡുകൾക്കിടയിൽ സന്ദേശങ്ങൾ വിശ്വസനീയമായി അയയ്ക്കുന്നു.


For this, we need a network protocol that Alice and Bob can run.

ഇതിനായി, ആലീസിനും ബോബിനും പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു നെറ്റ്‌വർക്ക് പ്രോട്ടോക്കോൾ ആവശ്യമാണ്.


Alice sends application messages m1,...,mn in that order.

ആലിസ് ആപ്ലിക്കേഷൻ സന്ദേശങ്ങൾ m1,...,mn എന്ന ക്രമത്തിൽ അയയ്ക്കുന്നു.


Also, if the network is fair and Alice sends application message m, then eventually Bob should deliver m.

കൂടാതെ, നെറ്റ്‌വർക്ക് നീതിയുക്തമാണെങ്കിൽ, ആലീസ് ആപ്ലിക്കേഷൻ സന്ദേശം m അയയ്ക്കുകയാണെങ്കിൽ, ഒടുവിൽ ബോബ് m വിതരണം ചെയ്യണം.


The Alternating Bit Protocol is suitable for our purposes.

ആൾട്ടർനേറ്റിംഗ് ബിറ്റ് പ്രോട്ടോക്കോൾ നമ്മുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമാണ്.


We assume that there are two unreliable network channels.

രണ്ട് വിശ്വാസമില്ലാത്ത നെറ്റ്‌വർക്ക് ചാനലുകൾ ഉണ്ടെന്ന് നമ്മൾ കരുതുന്നു.


Alice sends a network message to Bob containing an application message as payload.

ആലീസ് ഒരു ആപ്ലിക്കേഷൻ സന്ദേശം പേലോഡായി ഉൾക്കൊള്ളുന്ന ഒരു നെറ്റ്‌വർക്ക് സന്ദേശം ബോബിന് അയയ്ക്കുന്നു.


When Bob receives such a network message, Bob returns an acknowledgment to Alice.

ബോബ് അത്തരം ഒരു നെറ്റ്‌വർക്ക് സന്ദേശം സ്വീകരിക്കുമ്പോൾ, ബോബ് ആലീസിന് ഒരു അംഗീകാരം നൽകുന്നു.


ഇതിനെ വീണ്ടും പ്രക്ഷേപണം എന്ന് വിളിക്കുന്നു.


Bob, on the other hand, waits until he receives a message matching Bob’s sequence number.

മറുവശത്ത്, ബോബിന്റെ സീക്വൻസ് നമ്പറുമായി പൊരുത്തപ്പെടുന്ന ഒരു സന്ദേശം ലഭിക്കുന്നതുവരെ ബോബ് കാത്തിരിക്കുന്നു.


Because of the network properties, a one-bit sequence number suffices.

നെറ്റ്‌വർക്ക് പ്രോപ്പർട്ടികൾ കാരണം, ഒരു-ബിറ്റ് സീക്വൻസ് നമ്പർ മതിയാകും.


The method places either m (to model a successful send) or () (to model loss) in !pchan.

വിജയകരമായ അയയ്‌ക്കൽ (send) മോഡൽ ചെയ്യാൻ m അല്ലെങ്കിൽ നഷ്ടം മോഡൽ ചെയ്യാൻ () എന്നിവ !pchan-ൽ ഈ രീതി സ്ഥാപിക്കുന്നു.


Method appsend(net, seq, msg) retransmits {.seq: !seq, .payload:msg} until an acknowledgment for !seq is received.

Appsend(net, seq, msg) രീതി !seq-നുള്ള അംഗീകാരം ലഭിക്കുന്നതുവരെ {.seq: !seq, .payload:msg} വീണ്ടും പ്രക്ഷേപണം ചെയ്യുന്നു.


Figure 22.2 shows how the methods may be used to send and receive a stream of NMSGSmessages reliably.

NMSG സന്ദേശങ്ങളുടെ ഒരു സ്ട്രീം വിശ്വസനീയമായി അയയ്‌ക്കാനും സ്വീകരിക്കാനും ഈ രീതികൾ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ചിത്രം 22.2-ൽ കാണിക്കുന്നു.


The number of messages must be bounded, because model checking requires a finite model.

മോഡൽ പരിശോധനയ്ക്ക് പരിമിതമായ ഒരു മാതൃക ആവശ്യമായതിനാൽ സന്ദേശങ്ങളുടെ എണ്ണം പരിമിതപ്പെടുത്തണം.


Develop a protocol for a single client and server using the same network model as for the ABP protocol.

ABP പ്രോട്ടോക്കോളിനായി ഉപയോഗിച്ച അതേ നെറ്റ്‌വർക്ക് മാതൃക ഉപയോഗിച്ച് ഒരു ക്ലയിന്റിനും സെർവറിനുമായി ഒരു പ്രോട്ടോക്കോൾ വികസിപ്പിക്കുക.


Leader election is the problem of electing a unique leader in a network of processors.

ലീഡർ തിരഞ്ഞെടുപ്പ് എന്നത് പ്രോസസ്സറുകളുടെ ഒരു നെറ്റ്‌വർക്കിൽ ഒരു അദ്വിതീയ നേതാവിനെ തിരഞ്ഞെടുക്കുന്ന പ്രശ്നമാണ്.


Typically this is challenging because the processors have only limited information.

പ്രോസസ്സറുകൾക്ക് പരിമിതമായ വിവരങ്ങൾ മാത്രമേ ഉണ്ടാകൂ എന്നതിനാലാണ് ഇത് സാധാരണയായി വെല്ലുവിളിയാകുന്നത്.


In the version that we present, each processor has a unique identifier.

ഞങ്ങൾ അവതരിപ്പിക്കുന്ന പതിപ്പിൽ, ഓരോ പ്രോസസ്സറിനും ഒരു അദ്വിതീയ ഐഡന്റിഫയർ ഉണ്ട്.


The protocol that we present elects as leader the processor with the highest identifier.

ഞങ്ങൾ അവതരിപ്പിക്കുന്ന പ്രോട്ടോക്കോൾ ഏറ്റവും ഉയർന്ന ഐഡന്റിഫയർ ഉള്ള പ്രോസസ്സറിനെ നേതാവായി തിരഞ്ഞെടുക്കുന്നു.


The file service implementation will use a collection of worker threads synchronizing using both ordinary locks and reader/writer locks.

ഫയൽ സേവന നടപ്പാക്കൽ സാധാരണ ലോക്കുകളും റീഡർ/റൈറ്റർ ലോക്കുകളും ഉപയോഗിച്ച് സമന്വയിപ്പിക്കുന്ന, വർക്കർ ത്രെഡുകളുടെ ഒരു ശേഖരം ഉപയോഗിക്കും.


Clients of the file service implementation (threads themselves) use blocking synchronized queues to communicate with the workers.

ഫയൽ സേവന നടപ്പാക്കലിന്റെ ക്ലയിന്റുകൾ (ത്രെഡുകൾ തന്നെ) വർക്കർമാരുമായി ആശയവിനിമയം നടത്താൻ ബ്ലോക്കിംഗ് സമന്വയ ക്യൂകൾ ഉപയോഗിക്കുന്നു.


In practice, there are many aspects to a file system.

പ്രായോഗികമായി, ഒരു ഫയൽ സിസ്റ്റത്തിന് നിരവധി വശങ്ങളുണ്ട്.


We will focus here on a low-level notion of a file, where the file abstraction is identified by a number (the so-called “inode number” or ino) and consists of a sequence of fixed-sized blocks.

ഇവിടെ, ഫയലിന്റെ താഴ്ന്ന നിലയിലുള്ള ഒരു ആശയത്തിൽ ഞങ്ങൾ ശ്രദ്ധ കേന്ദ്രീകരിക്കും, അവിടെ ഫയൽ അബ്‌സ്ട്രാക്ഷനെ ഒരു സംഖ്യ ഉപയോഗിച്ച് തിരിച്ചറിയുന്നു (അതായത് “inode നമ്പർ” അല്ലെങ്കിൽ ino) കൂടാതെ സ്ഥിര വലുപ്പത്തിലുള്ള ബ്ലോക്കുകളുടെ ഒരു ശ്രേണി ഇതിൽ അടങ്ങിയിരിക്കുന്നു.


In our abstraction, each block holds an arbitrary Harmony value.

ഞങ്ങളുടെ അബ്‌സ്ട്രാക്ഷനിൽ, ഓരോ ബ്ലോക്കും ഒരു ഏകപക്ഷീയമായ ഹാർമണി മൂല്യം നിലനിർത്തുന്നു.


If you want to remain more truthful to reality, you might only store lists of numbers of fixed length in a block, representing a block of bytes.

നിങ്ങൾ യാഥാർത്ഥ്യത്തോട് കൂടുതൽ സത്യസന്ധത പുലർത്താൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഒരു ബ്ലോക്കിൽ നിശ്ചിത ദൈർഘ്യമുള്ള സംഖ്യകളുടെ ലിസ്റ്റുകൾ മാത്രമേ നിങ്ങൾക്ക് സംഭരിക്കാൻ കഴിയൂ, ഇത് ഒരു ബ്ലോക്ക് ബൈറ്റുകളെ പ്രതിനിധീകരിക്കുന്നു.


A more complete file system would keep track of various additional information about each file, such as its size in bytes, its owner, its access rights, and when the file was last modified.

കൂടുതൽ പൂർണ്ണമായ ഒരു ഫയൽ സിസ്റ്റം ഓരോ ഫയലിനെക്കുറിച്ചുമുള്ള വിവിധ അധിക വിവരങ്ങൾ ട്രാക്ക് ചെയ്യും, അതായത് അതിന്റെ വലുപ്പം, ഉടമ, ആക്സസ് അവകാശങ്ങൾ, ഫയൽ അവസാനമായി എപ്പോൾ പരിഷ്കരിച്ചു എന്നുള്ള വിവരങ്ങൾ.


Moreover, a system of folders (a.k.a. directories) built on top of the files would associate user-readable names to the files.

കൂടാതെ, ഫയലുകൾക്ക് മുകളിൽ നിർമ്മിച്ചിട്ടുള്ള ഫോൾഡറുകളുടെ (അതായത് ഡയറക്ടറികൾ) ഒരു സിസ്റ്റം ഉപയോക്തൃ-പ്രദർശനീയമായ പേരുകൾ ഫയലുകളുമായി ബന്ധിപ്പിക്കും.


File(n) returns a handle that must be passed to file operations, wherenis the maximum number of files.

File(n) ഫയൽ പ്രവർത്തനങ്ങൾക്ക് കൈമാറേണ്ട ഒരു ഹാൻഡിൽ നൽകുന്നു, ഇവിടെ n എന്നത് പരമാവധി ഫയലുകളുടെ എണ്ണമാണ്.


For our example, we have only included three operations on files.

ഞങ്ങളുടെ ഉദാഹരണത്തിനായി, ഫയലുകളിൽ മൂന്ന് പ്രവർത്തനങ്ങൾ മാത്രമേ ഉൾപ്പെടുത്തിയിട്ടുള്ളൂ.


read(fs,ino,offset) returns the block of fileino at the given offset, or None if nothing has been stored at that offset.

read(fs,ino,offset) നൽകിയിട്ടുള്ള ഓഫ്‌സെറ്റിൽ fileino-യുടെ ബ്ലോക്ക് നൽകുന്നു, അല്ലെങ്കിൽ ആ ഓഫ്‌സെറ്റിൽ ഒന്നും സംഭരിച്ചിട്ടില്ലെങ്കിൽ None നൽകുന്നു.


write(fs,ino,offset,data) stores data at the given offset in fileino.

write(fs,ino,offset,data) fileino-യിലെ നൽകിയിട്ടുള്ള ഓഫ്‌സെറ്റിൽ ഡാറ്റ സംഭരിക്കുന്നു.


If needed, the file is grown to include the given offset.

ആവശ്യമെങ്കിൽ, നൽകിയിട്ടുള്ള ഓഫ്‌സെറ്റ് ഉൾപ്പെടുത്തുന്നതിനായി ഫയൽ വലുതാക്കുന്നു.


“Holes” (unwritten blocks) are plugged with None values.

“ഹോളുകൾ” (എഴുതാത്ത ബ്ലോക്കുകൾ) None മൂല്യങ്ങൾ ഉപയോഗിച്ച് പ്ലഗ് ചെയ്യുന്നു.


delete(fs,ino) ഒരു ഫയൽ ഇല്ലാതാക്കുന്നു.


As shown in Chapter 10, we can test a concurrent system by checking all interleavings of some selection of its operations.

അധ്യായം 10-ൽ കാണിച്ചിട്ടുള്ളതുപോലെ, അതിന്റെ ചില പ്രവർത്തനങ്ങളുടെ എല്ലാ ഇന്റർലീവിംഗുകളും പരിശോധിക്കുന്നതിലൂടെ നമുക്ക് ഒരു സമകാലിക സിസ്റ്റം പരീക്ഷിക്കാൻ കഴിയും.


We can do this for both the specification and implementation of the file system and check that every behavior of the implementation is also a behavior of the specification.

ഫയൽ സിസ്റ്റത്തിന്റെ സ്പെസിഫിക്കേഷനും നടപ്പാക്കലിനും ഇത് ചെയ്യാൻ കഴിയും, കൂടാതെ നടപ്പാക്കലിന്റെ എല്ലാ സ്വഭാവവും സ്പെസിഫിക്കേഷന്റെ സ്വഭാവമാണെന്ന് പരിശോധിക്കാനും കഴിയും.


To store the file system, we will use a disk.

ഫയൽ സിസ്റ്റം സംഭരിക്കുന്നതിന്, ഞങ്ങൾ ഒരു ഡിസ്ക് ഉപയോഗിക്കും.


Like a file, a disk is an array of blocks, albeit one of fixed length.

ഒരു ഫയലിനെപ്പോലെ, ഒരു ഡിസ്ക് ബ്ലോക്കുകളുടെ ഒരു ശ്രേണിയാണ്, സ്ഥിരമായ നീളമുള്ള ഒന്ന്.


Each block is identified by its offset or block number.

ഓരോ ബ്ലോക്കും അതിന്റെ ഓഫ്‌സെറ്റ് അല്ലെങ്കിൽ ബ്ലോക്ക് നമ്പർ ഉപയോഗിച്ച് തിരിച്ചറിയപ്പെടുന്നു.


A replica receives a failure notification, it updates its configuration accordingly.

ഒരു പ്രതിവിധിക്ക് ഒരു പരാജയ അറിയിപ്പ് ലഭിക്കുമ്പോൾ, അതനുസരിച്ച് അതിന്റെ കോൺഫിഗറേഷൻ അപ്‌ഡേറ്റ് ചെയ്യുന്നു.


When a non-head replica receives a history that extends its own history, then the replica adopts the received history.

ഒരു തലവനല്ലാത്ത പ്രതിവിധിക്ക് അതിന്റെ സ്വന്തം ചരിത്രം വിപുലീകരിക്കുന്ന ഒരു ചരിത്രം ലഭിക്കുമ്പോൾ, പ്രതിവിധി സ്വീകരിച്ച ചരിത്രം സ്വീകരിക്കുന്നു.


If a replica is the head, it adds any requests it has received to its history unless they are already on there.

ഒരു പ്രതിവിധി തലവനാണെങ്കിൽ, അതിന് ലഭിച്ച ഏതെങ്കിലും അഭ്യർത്ഥനകൾ ഇതിനകം അവിടെയുണ്ടെങ്കിൽ, അത് അതിന്റെ ചരിത്രത്തിലേക്ക് ചേർക്കുന്നു.


If a replica is the tail, it “delivers” operations on its history (by printing the operation) that it has not already delivered.

ഒരു പ്രതിവിധി വാലാണെങ്കിൽ, അത് ഇതിനകം വിതരണം ചെയ്യാത്ത അതിന്റെ ചരിത്രത്തിലെ പ്രവർത്തനങ്ങൾ (പ്രവർത്തനം പ്രിന്റ് ചെയ്യുന്നതിലൂടെ) “വിതരണം” ചെയ്യുന്നു.


For this, it maintains a counterdelivered that counts the number of delivered requests.

ഇതിനായി, വിതരണം ചെയ്ത അഭ്യർത്ഥനകളുടെ എണ്ണം കണക്കാക്കുന്ന ഒരു കൗണ്ടർഡെലിവേർഡ് ഇത് നിലനിർത്തുന്നു.


Any replica that is not the tail sends its history to its successor in the chain.

വാലല്ലാത്ത ഏതൊരു പ്രതിവിധിയും അതിന്റെ ചരിത്രം ശൃംഖലയിലെ അതിന്റെ പിൻഗാമിക്കായി അയയ്ക്കുന്നു.


The question is whether chain replication has the same behavior as the replicated state machine specification.

ചെയിൻ റെപ്ലിക്കേഷന്, പകർത്തിയ സ്റ്റേറ്റ് മെഷീൻ സ്പെസിഫിക്കേഷന്റെ അതേ സ്വഭാവമുണ്ടോ എന്നതാണ് ചോദ്യം.


This can be checked using the following two Harmony commands.

ഇനിപ്പറയുന്ന രണ്ട് ഹാർമണി കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് പരിശോധിക്കാൻ കഴിയും.


The first command outputs the behavior DFA.

ആദ്യ കമാൻഡ് ബിഹേവിയർ DFA ഔട്ട്പുട്ട് ചെയ്യുന്നു.


The second command checks that the behavior satisfies the DFA.

സ്വഭാവം DFA-യെ തൃപ്തിപ്പെടുത്തുന്നുണ്ടോ എന്ന് രണ്ടാമത്തെ കമാൻഡ് പരിശോധിക്കുന്നു.


Note that chain replication does not produce all the possible behaviors of a replicated state machine, but all its behaviors are valid.

ചെയിൻ റെപ്ലിക്കേഷൻ, പകർത്തിയ സ്റ്റേറ്റ് മെഷീന്റെ എല്ലാ സാധ്യതയുള്ള സ്വഭാവങ്ങളും ഉണ്ടാക്കുന്നില്ല, എന്നാൽ അതിന്റെ എല്ലാ സ്വഭാവങ്ങളും സാധുതയുള്ളവയാണെന്നത് ശ്രദ്ധിക്കുക.


The model has each replica send its entire history each time it extends its history.

മോഡൽ, ഓരോ പ്രതിവിധിയും അതിന്റെ ചരിത്രം വിപുലീകരിക്കുമ്പോഴെല്ലാം അതിന്റെ മുഴുവൻ ചരിത്രവും അയയ്ക്കുന്നു.


This is fine for modeling, but in practice that would not scale.

മോഡലിംഗിന് ഇത് നല്ലതാണ്, എന്നാൽ പ്രായോഗികമായി ഇത് സ്കെയിൽ ചെയ്യില്ല.


In practice, a predecessor would set up a TCP connection to its successor and only send updates to its history along the TCP connection.

പ്രായോഗികമായി, ഒരു മുൻഗാമി അതിന്റെ പിൻഗാമിയുമായി ഒരു TCP കണക്ഷൻ സ്ഥാപിക്കുകയും TCP കണക്ഷനിലൂടെ അതിന്റെ ചരിത്രത്തിലേക്ക് അപ്‌ഡേറ്റുകൾ അയയ്ക്കുകയും ചെയ്യും.


Because TCP connections guarantee FIFO order, this would be identical to the predecessor sending a series of histories, but much more efficient.

TCP കണക്ഷനുകൾ FIFO ക്രമം ഉറപ്പുനൽകുന്നതിനാൽ, ഇത് മുൻഗാമി ഒരു ചരിത്ര പരമ്പര അയയ്ക്കുന്നതിന് തുല്യമായിരിക്കും, എന്നാൽ കൂടുതൽ കാര്യക്ഷമമാണ്.


So far we have mostly modeled concurrent activities using threads.

ഇതുവരെ, ഞങ്ങൾ പ്രധാനമായും ത്രെഡുകൾ ഉപയോഗിച്ച് സമകാലിക പ്രവർത്തനങ്ങൾ മാതൃകയാക്കിയിട്ടുണ്ട്.


Another way of modeling is by enumerating all the possible state transitions from any given state.

ഏതൊരു അവസ്ഥയിൽ നിന്നും സാധ്യമായ എല്ലാ സ്റ്റേറ്റ് ട്രാൻസിഷനുകളും എണ്ണുന്നതിലൂടെയും മോഡലിംഗ് ചെയ്യാം.


For example, this is how things are commonly specified in TLA+.

ഉദാഹരണത്തിന്, TLA+ൽ കാര്യങ്ങൾ സാധാരണയായി വ്യക്തമാക്കുന്നത് ഇങ്ങനെയാണ്.


As in TLA+, we call such state transitions actions.

TLA+ൽ എന്നപോലെ, അത്തരം സ്റ്റേറ്റ് ട്രാൻസിഷനുകളെ നമ്മൾ പ്രവർത്തനങ്ങൾ എന്ന് വിളിക്കുന്നു.


In this chapter we will revisit modeling chain replication, but this time using actions.

ഈ അധ്യായത്തിൽ, ഞങ്ങൾ ചെയിൻ റെപ്ലിക്കേഷൻ മോഡലിംഗ് വീണ്ടും സന്ദർശിക്കും, എന്നാൽ ഈ സമയം പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച്.


The leader then moves on to the second round.

അതിനുശേഷം നേതാവ് രണ്ടാം റൗണ്ടിലേക്ക് നീങ്ങുന്നു.


To run and check the Paxos code, do the following.

പാക്സോസ് കോഡ് പ്രവർത്തിപ്പിക്കാനും പരിശോധിക്കാനും, താഴെ പറയുന്നവ ചെയ്യുക.


ആക്രമണം ഇങ്ങനെയാണ്:


Alice creates a new nonce NA and sends it to Corey.

ആലീസ് ഒരു പുതിയ നോൺസ് NA ഉണ്ടാക്കുകയും അത് കോറിക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.


If Bob finishes the protocol with Alice and received AN from Alice, then nobody but Bob and Alice can learn NA.

ആലീസുമായി ബോബ് പ്രോട്ടോക്കോൾ പൂർത്തിയാക്കുകയും ആലീസിൽ നിന്ന് AN സ്വീകരിക്കുകയും ചെയ്താൽ, ബോബിനും ആലീസിനും  അല്ലാതെ മറ്റാർക്കും NA അറിയാൻ കഴിയില്ല.


The Needham-Schroeder protocol is a security protocol.

നീഡ്ഹാം-ഷ്റോഡർ പ്രോട്ടോക്കോൾ ഒരു സുരക്ഷാ പ്രോട്ടോക്കോൾ ആണ്.


Model checking can be used to find the bug.

മോഡൽ പരിശോധന ബഗ് കണ്ടെത്താൻ ഉപയോഗിക്കാം.


സുരക്ഷാ സ്വഭാവം ലംഘിക്കപ്പെടുന്നു.


In this version, the responses to the second phase are matched not by ballot number but by the value of the proposal.

ഈ പതിപ്പിൽ, രണ്ടാം ഘട്ടത്തിലുള്ള പ്രതികരണങ്ങൾ ബാലറ്റ് നമ്പറിനനുസരിച്ചല്ല, നിർദ്ദേശത്തിന്റെ മൂല്യത്തിനനുസരിച്ചാണ് പൊരുത്തപ്പെടുന്നത്.


ആലീസിന് ബോബുമായി ആശയവിനിമയം നടത്തണം.


The three critical steps in the Needham-Schroeder protocol are as follows:

നീഡ്ഹാം-ഷ്റോഡർ പ്രോട്ടോക്കോളിന്റെ മൂന്ന് നിർണായക ഘട്ടങ്ങൾ ഇതാ:


When Bob receives the message, he does not know for sure that the message came from Alice.

ബോബ് സന്ദേശം സ്വീകരിക്കുമ്പോൾ, സന്ദേശം ആലീസിൽ നിന്നുള്ളതാണെന്ന് ഉറപ്പില്ല.


The model checker checks for overflow on various operations.

വിവിധ ഓപ്പറേഷനുകളിൽ ഓവർഫ്ലോ ഉണ്ടോയെന്ന് മോഡൽ പരിശോധകൻ പരിശോധിക്കുന്നു.


In Harmony, there is no distinction between tuples and lists.

ഹാർമണിയിൽ, ട്യൂപ്പിളുകളും ലിസ്റ്റുകളും തമ്മിൽ വ്യത്യാസമില്ല.


A dictionary maps a set of values to another set of values.

ഒരു നിഘണ്ടു, മൂല്യങ്ങളുടെ ഒരു കൂട്ടത്തെ മറ്റൊരു കൂട്ടത്തിലേക്ക് മാപ്പ് ചെയ്യുന്നു.


Bytecode address is an integer that can be used to index into Harmony bytecode.

ബൈറ്റ്കോഡ് വിലാസം എന്നത് ഹാർമണി ബൈറ്റ്കോഡിലേക്ക് സൂചിക നൽകാൻ ഉപയോഗിക്കാവുന്ന ഒരു പൂർണ്ണസംഖ്യയാണ്.


A Harmony address is a type of thunk consisting of a curried function and a list of arguments.

ഒരു ഹാർമണി വിലാസം എന്നത് ഒരു കറീഡ് ഫംഗ്ഷനും ആർഗ്യുമെന്റുകളുടെ ഒരു ലിസ്റ്റും അടങ്ങുന്ന ഒരു തരം തങ്കാണ്.


മോഡൽ പരിശോധകൻ ഓവർഫ്ലോ പരിശോധിക്കുന്നു.


The code for Alice and Bob simply follows the steps listed above.

ആലീസിനും ബോബിനുമുള്ള കോഡ് മുകളിൽ ലിസ്റ്റ് ചെയ്ത ഘട്ടങ്ങൾ പിന്തുടരുന്നു.


The attack goes like this: Alice creates a new nonce NA and sends it to Corey.

ആക്രമണം ഇങ്ങനെയാണ്: ആലീസ് ഒരു പുതിയ നോൺസ് NA ഉണ്ടാക്കുകയും അത് കോറിക്ക് അയയ്ക്കുകയും ചെയ്യുന്നു.


The program uses the malloc() function to allocate memory.

പ്രോഗ്രാം മെമ്മറി അനുവദിക്കാൻ malloc() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.


The module provides methods for working with bags or multisets.

ഈ മൊഡ്യൂൾ ബാഗുകളോ മൾട്ടിസെറ്റുകളോ ഉപയോഗിച്ച് പ്രവർത്തിക്കാനുള്ള രീതികൾ നൽകുന്നു.


The Hoare module implements support for Hoare-style monitors and condition variables.

ഹോയർ ശൈലിയിലുള്ള മോണിറ്ററുകളും കണ്ടീഷൻ വേരിയബിളുകളും ഈ ഹോയർ മൊഡ്യൂൾ നടപ്പിലാക്കുന്നു.


The lists module has methods to operate on lists or tuples.

ലിസ്റ്റുകളിലോ ട്യൂപ്പിളുകളിലോ പ്രവർത്തിക്കാനുള്ള രീതികൾ ലിസ്റ്റ് മൊഡ്യൂളിനുണ്ട്.


The sets module implements methods like add and remove.

സെറ്റുകൾ ചേർക്കാനും നീക്കം ചെയ്യാനും സഹായിക്കുന്ന രീതികൾ സെറ്റ് മൊഡ്യൂളിൽ ഉണ്ട്.


The synch module provides methods for synchronization.

സമന്വയത്തിനായി സിൻക് മൊഡ്യൂൾ രീതികൾ നൽകുന്നു.


The thread module implements the fork/join interface.

ത്രെഡുകൾക്കായി ഫോർക്ക്/ജോയിൻ ഇന്റർഫേസ് ത്രെഡ് മൊഡ്യൂൾ നടപ്പിലാക്കുന്നു.


The Harmony Virtual Machine has a specific state.

ഹാർമണി വെർച്വൽ മെഷീന് ഒരു പ്രത്യേക അവസ്ഥയുണ്ട്.


ഓരോ ഘട്ടവും ഒരു പുതിയ അവസ്ഥ ഉണ്ടാക്കുന്നു.


എച്ച്‌വിഎം ഘട്ടങ്ങളല്ല, സ്‌ട്രൈഡുകളാണ് ഇടകലർത്തുന്നത്.


Executing a Harmony program results in a graph.

ഒരു ഹാർമണി പ്രോഗ്രാം നടപ്പിലാക്കുന്നത് ഒരു ഗ്രാഫിലാണ് കലാശിക്കുന്നത്.


If there are no exceptions, Harmony computes the strongly connected components.

അപവാദങ്ങളൊന്നും ഇല്ലെങ്കിൽ, ഹാർമണി ശക്തമായി ബന്ധിപ്പിച്ച ഘടകങ്ങൾ കണക്കാക്കുന്നു.


The compiler turns your Harmony program into bytecode.

കമ്പൈലർ നിങ്ങളുടെ ഹാർമണി പ്രോഗ്രാമിനെ ബൈറ്റ്കോഡിലേക്ക് മാറ്റുന്നു.


The model checker explores the entire state space.

മോഡൽ ചെക്കർ മുഴുവൻ സ്റ്റേറ്റ് സ്പേസും പരിശോധിക്കുന്നു.


ഹാർമണി ഇൻപുട്ടിനെ പിന്തുണക്കുന്നില്ല.


ഒരു ത്രെഡിന് ആറ്റോമിക് മോഡിൽ ആയിരിക്കാം അല്ലെങ്കിൽ അല്ലാതിരിക്കാം.


The model checker maintains a bag of contexts.

മോഡൽ ചെക്കർ ഒരു കൂട്ടം സന്ദർഭങ്ങൾ നിലനിർത്തുന്നു.


An execution can fail for a variety of reasons.

നിരവധി കാരണങ്ങളാൽ ഒരു എക്സിക്യൂഷൻ പരാജയപ്പെടാം.


The output of the model checker is a graph.

മോഡൽ ചെക്കറിൻ്റെ ഔട്ട്‌പുട്ട് ഒരു ഗ്രാഫാണ്.


If some execution failed, Harmony will report the path.

ചില എക്സിക്യൂഷനുകൾ പരാജയപ്പെട്ടാൽ, ഹാർമണി ആ പാത റിപ്പോർട്ട് ചെയ്യും.


The Harmony program uses bytecode addresses for methods and lambdas.

ഹാർമണി പ്രോഗ്രാം രീതികളും ലാംഡകളും ഉപയോഗിക്കുന്നതിന് ബൈറ്റ്കോഡ് വിലാസങ്ങൾ ഉപയോഗിക്കുന്നു.


A delayed call to a method with an argument is represented by a thunk.

ഒരു ആർഗ്യുമെൻ്റുള്ള ഒരു രീതിയിലേക്കുള്ള കാലതാമസമുള്ള കോൾ ഒരു തംക് ആയി പ്രതിനിധീകരിക്കുന്നു.


Generators can be implemented using this delayed call mechanism.

ഈ കാലതാമസമുള്ള കോൾ സംവിധാനം ഉപയോഗിച്ച് ജനറേറ്ററുകൾ നടപ്പിലാക്കാൻ കഴിയും.


The Harmony program does not run into failing assertions in a specific example.

ഒരു പ്രത്യേക ഉദാഹരണത്തിൽ, ഹാർമണി പ്രോഗ്രാം പരാജയപ്പെടുന്ന അവകാശവാദങ്ങളിലേക്ക് കടന്നുപോകാറില്ല.


Harmony uses the address of a method variable internally.

ഹാർമണി ആന്തരികമായി ഒരു രീതി വേരിയബിളിൻ്റെ വിലാസം ഉപയോഗിക്കുന്നു.


The address of a method variable is output as ?@k.

?@k ആയി ഒരു രീതി വേരിയബിളിൻ്റെ വിലാസം ഔട്ട്പുട്ട് ചെയ്യുന്നു.


There is no such thing as the address of a local variable at the Harmony language level.

ഹാർമണി ഭാഷാ തലത്തിൽ ഒരു പ്രാദേശിക വേരിയബിളിൻ്റെ വിലാസം എന്നൊന്നില്ല.


In the program on the left, x is a shared variable.

ഇടതുവശത്തുള്ള പ്രോഗ്രാമിൽ, x ഒരു പങ്കിട്ട വേരിയബിളാണ്.


In the program on the right, x is a local variable.

വലതുവശത്തുള്ള പ്രോഗ്രാമിൽ, x ഒരു പ്രാദേശിക വേരിയബിളാണ്.


?x evaluates x and then takes its address.

?x, x-നെ വിലയിരുത്തുകയും തുടർന്ന് അതിൻ്റെ വിലാസം എടുക്കുകയും ചെയ്യുന്നു.


Harmony supports the shorthand p → v for the expression (!p).v.

(!p).v എന്ന എക്സ്പ്രഷനുവേണ്ടി ഹാർമണി p → v എന്ന ചുരുക്കെഴുത്ത് പിന്തുണയ്ക്കുന്നു.


A context value captures the state of a thread.

ഒരു സന്ദർഭ മൂല്യം ഒരു ത്രെഡിൻ്റെ അവസ്ഥയെ ഉൾക്കൊള്ളുന്നു.


The save expression returns a tuple (e, c).

സേവ് എക്സ്പ്രഷൻ (e, c) എന്ന ട്യൂപ്പിൾ നൽകുന്നു.


Using go, the context can be turned into a new thread.

go ഉപയോഗിച്ച്, സന്ദർഭം ഒരു പുതിയ ത്രെഡായി മാറ്റാൻ കഴിയും.


A thread can be suspended using stop None or just stop().

stop None അല്ലെങ്കിൽ stop() ഉപയോഗിച്ച് ഒരു ത്രെഡിനെ സസ്പെൻഡ് ചെയ്യാൻ കഴിയും.


Harmony supports various statements, including assignment and assert.

അസൈൻമെൻ്റും, ആസ്വാദ്നവും ഉൾപ്പെടെ വിവിധ പ്രസ്താവനകളെ ഹാർമണി പിന്തുണയ്ക്കുന്നു.


The statement x = 3 changes the state by assigning 3 to variable x.

x = 3 എന്ന പ്രസ്താവന x എന്ന വേരിയബിളിന് 3 നൽകി അവസ്ഥ മാറ്റുന്നു.


The statement x = y = 3 first updates y, then x.

x = y = 3 എന്ന പ്രസ്താവന ആദ്യം y-യും, തുടർന്ന് x-ഉം അപ്‌ഡേറ്റ് ചെയ്യുന്നു.


The statement assert b evaluates b and reports an error if b is false.

assert b എന്ന പ്രസ്താവന b-യെ വിലയിരുത്തുകയും b തെറ്റാണെങ്കിൽ ഒരു പിശക് റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.


A statement can be preceded by the atomically keyword to make the statement atomic.

ഒരു പ്രസ്താവനയെ അറ്റോമിക് ആക്കുന്നതിന്, ആ പ്രസ്താവനയ്ക്ക് മുമ്പ് ആറ്റോമികലി എന്ന കീവേഡ് ഉപയോഗിക്കാം.


The Harmony compiler and model checker are used for the Harmony programming language.

ഹാർമണി പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്കായി ഹാർമണി കംപൈലറും മോഡൽ ചെക്കറും ഉപയോഗിക്കുന്നു.


Harmony compiles Harmony into bytecode and then model checks the bytecode.

ഹാർമണി, ഹാർമണിയെ ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുകയും തുടർന്ന് ബൈറ്റ്കോഡ് മോഡൽ പരിശോധിക്കുകയും ചെയ്യുന്നു.


The result is analyzed for failing assertions and invariants.

പരാജയപ്പെട്ട ഉറപ്പുകളും ഇൻവേരിയന്റുകളും ഇതിന്റെ ഫലമായി വിശകലനം ചെയ്യപ്പെടുന്നു.


Non-terminating conditions such as deadlock and infinite loops are also checked.

ഡെഡ്‌ലോക്ക്, അനന്തമായ ലൂപ്പുകൾ തുടങ്ങിയ അവസാനം കാണാത്ത അവസ്ഥകളും പരിശോധിക്കുന്നു.


There are three phases: compile, model check, and analysis.

മൂന്ന് ഘട്ടങ്ങളുണ്ട്: കംപൈൽ ചെയ്യുക, മോഡൽ പരിശോധിക്കുക, വിശകലനം ചെയ്യുക.


The Harmony file name extensions are as follows: .hny, .hvm, .hco, .hvb, and .hfa.

ഹാർമണി ഫയൽ നാമ വിപുലീകരണങ്ങൾ ഇപ്രകാരമാണ്: .hny, .hvm, .hco, .hvb, കൂടാതെ .hfa.


Harmony can also generate .tla, .htm, .gv, .png, and .tex files.

ഹാർമണിക്ക് .tla, .htm, .gv, .png, കൂടാതെ .tex ഫയലുകളും ഉണ്ടാക്കാൻ കഴിയും.


By default, running 'harmony x.hny' will generate x.hvm, x.hco, x.hvb, x.png, and x.hvm files.

സ്വതവേ, 'harmony x.hny' പ്രവർത്തിപ്പിക്കുന്നത് x.hvm, x.hco, x.hvb, x.png, കൂടാതെ x.hvm ഫയലുകൾ ഉണ്ടാക്കും.


Various options can be used to change the behavior.

പ്രവർത്തനം മാറ്റുന്നതിന് വിവിധ ഓപ്ഷനുകൾ ഉപയോഗിക്കാം.


When importing a module using import x, harmony will try to find the corresponding .hny file.

import x ഉപയോഗിച്ച് ഒരു മൊഡ്യൂൾ ഇറക്കുമതി ചെയ്യുമ്പോൾ, അനുബന്ധ .hny ഫയൽ കണ്ടെത്താൻ ഹാർമണി ശ്രമിക്കും.


The options include output file options and other options.

ഓപ്ഷനുകളിൽ ഔട്ട്‌പുട്ട് ഫയൽ ഓപ്ഷനുകളും മറ്റ് ഓപ്ഷനുകളും ഉൾപ്പെടുന്നു.


The -ofilename.gv option specifies the name of the file where the graphviz (DOT) output should be stored.

-ofilename.gv എന്ന ഓപ്ഷൻ ഗ്രാഫ്വിസ് (DOT) ഔട്ട്‌പുട്ട് സൂക്ഷിക്കേണ്ട ഫയലിന്റെ പേര് വ്യക്തമാക്കുന്നു.


The -a option compiles only and lists machine code.

-a എന്ന ഓപ്ഷൻ കംപൈൽ ചെയ്യുകയും മെഷീൻ കോഡ് ലിസ്റ്റ് ചെയ്യുകയും ചെയ്യുന്നു.


Peterson's Algorithm is a solution to the mutual exclusion problem.

പരസ്പരം ഒഴിവാക്കാനുള്ള പ്രശ്നത്തിനുള്ള ഒരു പരിഹാരമാണ് പീറ്റേഴ്സൺസ് അൽഗോരിതം.


The HVM starts in an initial state in which there is only one thread.

ഒരു ത്രെഡ് മാത്രമുള്ള പ്രാരംഭ അവസ്ഥയിലാണ് HVM ആരംഭിക്കുന്നത്.


A trace is a sequence of steps starting from the initial state.

ആരംഭ അവസ്ഥയിൽ നിന്ന് തുടങ്ങുന്ന ഘട്ടങ്ങളുടെ ഒരു ശ്രേണിയാണ് ഒരു ട്രെയ്സ്.


A state is reachable if it can be reached from the initial state through a finite trace.

പരിമിതമായ ട്രാക്കിലൂടെ പ്രാരംഭ അവസ്ഥയിൽ നിന്ന് എത്തിച്ചേരാൻ കഴിയുമെങ്കിൽ ഒരു അവസ്ഥയിൽ എത്താനാകും.


An invariant of a program is a predicate that holds over all states that are reachable by that program.

ഒരു പ്രോഗ്രാമിന്റെ ഇൻവേരിയന്റ് എന്നത് ആ പ്രോഗ്രാം വഴി എത്തിച്ചേരാവുന്ന എല്ലാ അവസ്ഥകളിലും നിലനിൽക്കുന്ന ഒരു പ്രെഡിക്കേറ്റ് ആണ്.


We want to show that exclusivity is an invariant because mutual exclusion means that all reachable states are exclusive.

പരസ്പരം ഒഴിവാക്കൽ എന്നാൽ എല്ലാ എത്തിച്ചേരാവുന്ന അവസ്ഥകളും ഒഴിവാക്കാനാകുമെന്നതിനാൽ, എക്സ്ക്ലൂസിവിറ്റി ഒരു ഇൻവേരിയന്റാണെന്ന് നമ്മൾക്ക് കാണിക്കേണ്ടതുണ്ട്.


The Split Binary Semaphore (SBS) approach is a general technique for implementing conditional waiting.

കണ്ടീഷണൽ കാത്തിരിപ്പ് നടപ്പിലാക്കുന്നതിനുള്ള ഒരു പൊതുവായ സാങ്കേതികതയാണ് സ്പ്ലിറ്റ് ബൈനറി സെമാഫോർ (SBS) സമീപനം.


The code uses a bounded buffer to manage data flow between producers and consumers.

നിർമ്മാതാക്കളും ഉപഭോക്താക്കളും തമ്മിലുള്ള ഡാറ്റാ ഒഴുക്ക് നിയന്ത്രിക്കാൻ കോഡ് ഒരു പരിമിതമായ ബഫർ ഉപയോഗിക്കുന്നു.


Hoare monitors provide a mechanism for synchronization in concurrent programming.

സമാന്തര പ്രോഗ്രാമിംഗിൽ സമന്വയത്തിനായി ഹോർ മോണിറ്ററുകൾ ഒരു സംവിധാനം നൽകുന്നു.


A bounded buffer prevents producers from overwhelming consumers.

നിർമ്മാതാക്കൾ ഉപഭോക്താക്കളെ അമിതമായി പ്രേരിപ്പിക്കുന്നത് ഒരു പരിമിതമായ ബഫർ തടയുന്നു.


The program implements a producer-consumer problem using split binary semaphores.

വിഭജിച്ച ബൈനറി സെമാഫോറുകൾ ഉപയോഗിച്ച് ഒരു നിർമ്മാതാവ്-ഉപഭോക്താവ് പ്രശ്നം പ്രോഗ്രാം നടപ്പിലാക്കുന്നു.


Understanding concurrency is crucial for building efficient software.

കാര്യക്ഷമമായ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതിന് കൺകറൻസി മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.


The mutex semaphore is acquired when entering a monitor.

ഒരു മോണിറ്ററിലേക്ക് പ്രവേശിക്കുമ്പോൾ, മ്യൂട്ടెక్സ് സെമാഫോർ നേടുന്നു.


Method wait increments the condition’s counter.

മെത്തേഡ് കാത്തിരിക്കുക എന്നത് അവസ്ഥയുടെ കൗണ്ടർ വർദ്ധിപ്പിക്കുന്നു.


കോഡ് ഒരു പരിമിതമായ ബഫർ ഉപയോഗിക്കുന്നു.


Implementing a reader/writer lock with Hoare monitors is not straightforward.

ഹോർ മോണിറ്ററുകൾ ഉപയോഗിച്ച് ഒരു റീഡർ/റൈറ്റർ ലോക്ക് നടപ്പിലാക്കുന്നത് ലളിതമല്ല.


The simplest solution would be to peek at the counters.

ഏറ്റവും ലളിതമായ പരിഹാരം കൗണ്ടറുകളിൽ ഒളിഞ്ഞുനോക്കുക എന്നതാണ്.


The alternative is for the reader/writer implementation to keep track of that state explicitly.

റീഡർ/റൈറ്റർ നടപ്പിലാക്കലിന് ആ അവസ്ഥ വ്യക്തമായി ട്രാക്ക് ചെയ്യാൻ കഴിയും.


Concurrency can be improved if a thread downgrades its write lock.

ഒരു ത്രെഡ് അതിന്റെ റൈറ്റ് ലോക്ക് താഴ്ത്തിയാൽ കൺകറൻസി മെച്ചപ്പെടുത്താൻ കഴിയും.


The book discusses concurrent programming concepts.

പുസ്തകത്തിൽ കൺകറൻ്റ് പ്രോഗ്രാമിംഗ് ആശയങ്ങൾ ചർച്ച ചെയ്യുന്നു.


I received help from various people while writing this book.

ഈ പുസ്തകം എഴുതുമ്പോൾ പല ആളുകളിൽ നിന്നും എനിക്ക് സഹായം ലഭിച്ചു.


The Harmony language has support for monitors.

ഹാർമണി ഭാഷയ്ക്ക് മോണിറ്ററുകൾക്കുള്ള പിന്തുണയുണ്ട്.


The code uses mutexes for mutual exclusion.

പരസ്പരം ഒഴിവാക്കാൻ കോഡ് മ്യൂട്ടെക്സുകൾ ഉപയോഗിക്കുന്നു.


ഒരു ത്രെഡ് എന്നത് എക്സിക്യൂഷനിലുള്ള കോഡാണ്.


പ്രോഗ്രാം ഒരു സ്റ്റാക്ക് മെഷീൻ ഉപയോഗിക്കുന്നു.


Model checking is a formal verification method.

മോഡൽ പരിശോധന ഒരു ഔപചാരിക പരിശോധനാ രീതിയാണ്.


Understanding the producer/consumer problem is important.

നിർമ്മാതാവ്/ഉപഭോക്താവ് പ്രശ്നം മനസ്സിലാക്കുന്നത് പ്രധാനമാണ്.