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.

ஹலோ வேர்ல்ட்! ஒரு உன்னதமான அறிமுக நிரலாகும்.


This document explains the Harmony Virtual Machine.

இந்த ஆவணம் ஹார்மனி விர்ச்சுவல் மெஷினை விளக்குகிறது.


Critical sections are essential for concurrent programming.

ஒருங்கிணைந்த நிரலாக்கத்திற்கு முக்கியமான பிரிவுகள் அவசியம்.


Understanding Harmony methods and pointers is crucial.

ஹார்மனி முறைகள் மற்றும் சுட்டிகளைப் புரிந்துகொள்வது முக்கியம்.


Specifying a lock is a fundamental concept.

ஒரு பூட்டை குறிப்பிடுவது ஒரு அடிப்படை கருத்தாகும்.


பல பூட்டு செயலாக்கங்கள் உள்ளன.


Concurrent data structures require careful design.

ஒருங்கிணைந்த தரவு கட்டமைப்புகள் கவனமாக வடிவமைக்கப்பட வேண்டும்.


Testing and checking behaviors are important steps.

சோதனை மற்றும் நடத்தை சரிபார்ப்பது முக்கியமான படிகள்.


Debugging concurrent programs can be challenging.

ஒருங்கிணைந்த நிரல்களை பிழைத்திருத்துவது சவாலாக இருக்கலாம்.


Conditional waiting is a common technique.

நிபந்தனை காத்திருப்பு ஒரு பொதுவான நுட்பமாகும்.


Reader/Writer locks are useful in many scenarios.

ரீடர்/ரைட்டர் பூட்டுகள் பல சூழ்நிலைகளில் பயனுள்ளதாக இருக்கும்.


The bounded buffer is a classic example.

வரையறுக்கப்பட்ட இடையகம் ஒரு உன்னதமான எடுத்துக்காட்டு.


Condition variables help manage concurrency.

நிபந்தனை மாறிகள் ஒருங்கமைவை நிர்வகிக்க உதவுகின்றன.


Starvation can be a problem in concurrent systems.

ஒருங்கிணைந்த அமைப்புகளில் பட்டினி ஒரு பிரச்சனையாக இருக்கலாம்.


முட்டுக்கட்டை தவிர்க்க வேண்டிய ஒரு தீவிரமான பிரச்சினை.


Actors and message passing offer an alternative.

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


Barrier synchronization is a useful technique.

தடை ஒத்திசைவு ஒரு பயனுள்ள நுட்பமாகும்.


Advanced barrier synchronization can improve performance.

மேம்பட்ட தடை ஒத்திசைவு செயல்திறனை மேம்படுத்தும்.


The lock ensures that only one thread can access the critical section at a time.

பூட்டு ஒரே நேரத்தில் ஒரு நூல் முக்கியமான பகுதியை அணுக முடியும் என்பதை உறுதி செய்கிறது.


Atomic operations are crucial for implementing locks in concurrent programming.

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


The program uses a spinlock to prevent data races.

தரவுப் பந்தயங்களைத் தடுக்க இந்த நிரல் ஒரு ஸ்பின்லாக்கைப் பயன்படுத்துகிறது.


A ticket lock prevents starvation by using a counter and a dispenser.

டிக்கெட் பூட்டு ஒரு கவுண்டரையும் ஒரு விநியோகிப்பாளரையும் பயன்படுத்தி பட்டினி கிடப்பதைத் தடுக்கிறது.


The customer went to the ATM to withdraw money.

வாடிக்கையாளர் பணம் எடுக்க ஏடிஎம் சென்றார்.


The bank account balance was checked before the withdrawal.

பணம் எடுப்பதற்கு முன் வங்கிக் கணக்கின் இருப்பு சரிபார்க்கப்பட்டது.


Concurrency bugs like TOCTOE can be tricky to debug.

TOCTOE போன்ற ஒருங்கோடும் பிழைகள் பிழைத்திருத்தம் செய்ய தந்திரமானதாக இருக்கலாம்.


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

ஒருங்கிணைந்த நிரல்களில் ஒத்திசைவுக்கான மிகவும் பரவலான வடிவம் பூட்டுகளாகும்.


The queue data structure is maintained as a linked list.

வரிசை தரவு அமைப்பு ஒரு இணைக்கப்பட்ட பட்டியலாக பராமரிக்கப்படுகிறது.


The program uses atomic operations to ensure data consistency.

தரவு நிலைத்தன்மையை உறுதிப்படுத்த நிரல் அணுசக்தி செயல்பாடுகளைப் பயன்படுத்துகிறது.


The thread is blocked while waiting for the lock.

பூட்டுக்காக காத்திருக்கும்போது நூல் தடுக்கப்படுகிறது.


The program uses a test-and-set instruction for the lock implementation.

பூட்டு செயல்படுத்தலுக்காக நிரல் ஒரு சோதனை மற்றும் அமைவு வழிமுறையைப் பயன்படுத்துகிறது.


ஏடிஎம் பரிவர்த்தனை வெற்றிகரமாக முடிந்தது.


The customer's balance was insufficient for the withdrawal amount.

பணம் எடுக்கும் தொகைக்கு வாடிக்கையாளரின் இருப்பு போதுமானதாக இல்லை.


The program uses a modular approach to model checking.

மாதிரி சரிபார்ப்புக்கு நிரல் ஒரு மட்டு அணுகுமுறையைப் பயன்படுத்துகிறது.


The program is designed to handle multiple threads concurrently.

நிரல் ஒரே நேரத்தில் பல நூல்களைக் கையாள வடிவமைக்கப்பட்டுள்ளது.


The code uses a lock to protect the shared data structure.

பகிர்ந்த தரவு கட்டமைப்பைப் பாதுகாக்க குறியீடு ஒரு பூட்டைப் பயன்படுத்துகிறது.


The program demonstrates the use of a concurrent queue.

நிரல் ஒரு ஒருங்கிணைந்த வரிசையின் பயன்பாட்டை நிரூபிக்கிறது.


The implementation uses a linked list for the queue.

செயல்படுத்துதல் வரிசைக்காக ஒரு இணைக்கப்பட்ட பட்டியலைப் பயன்படுத்துகிறது.


The program avoids data races by using atomic operations.

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


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.

முக்கியமான பகுதிக்குள் நுழைய விரும்பும் ஒரு திரிக்கள் முதலில் பூட்டைப் பெற வேண்டும்.


The thread then executes the critical section.

பின்னர் திரிக்கள் முக்கியமான பகுதியை செயல்படுத்துகிறது.


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.

பீட்டர்சனின் வழிமுறை ஒரு முக்கியமான பகுதியை செயல்படுத்துகிறது, ஆனால் அது திறமையானது அல்ல.


Modern processors sometimes re-orders load and store operations.

நவீன செயலிகள் சில நேரங்களில் ஏற்றுதல் மற்றும் சேமிப்பு செயல்பாடுகளை மறுவரிசைப்படுத்துகின்றன.


The program chooses to print either “hello” or “world”.

அந்த நிரல் “hello” அல்லது “world” இரண்டில் ஒன்றை அச்சிடத் தேர்ந்தெடுக்கிறது.


The corresponding DFA captures both possibilities.

அதற்குரிய DFA இரண்டு சாத்தியக்கூறுகளையும் கைப்பற்றுகிறது.


You can think of the choose operator as enumerating all possible inputs to the program.

நிரலுக்குள் சாத்தியமான அனைத்து உள்ளீடுகளையும் எண்ணுவதாக choose ஆபரேட்டரை நீங்கள் நினைக்கலாம்.


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

எந்தவொரு நிரலும் முடிவடையும் திறன் கொண்டதாக இருக்க வேண்டும் என்று ஹார்மனி பொதுவாகக் கோருகிறது.


The possible outputs consist of zero or more copies of the string “hello world”.

சாத்தியமான வெளியீடுகள் “hello world” என்ற சரத்தின் ஒன்று அல்லது அதற்கு மேற்பட்ட பிரதிகளாகும்.


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

திரெட்கள் ஒரே நேரத்தில் இயங்குவதால், நிரல் “hello world” அல்லது “world hello” இரண்டில் ஒன்றை வெளியிடும்.


Printing in Harmony is atomic, so “hweolrllod” is not a possible output.

ஹார்மனியில் அச்சிடுதல் அணுசக்தியாகும், எனவே “hweolrllod” என்பது சாத்தியமான வெளியீடு அல்ல.


Now there are four possible outputs depending on how the two threads are interleaved, including “hello hello Lesley Robbert”.

இப்போது இரண்டு திரெட்கள் எவ்வாறு ஒன்றோடொன்று இணைக்கப்பட்டுள்ளன என்பதைப் பொறுத்து நான்கு சாத்தியமான வெளியீடுகள் உள்ளன, இதில் “hello hello Lesley Robbert” அடங்கும்.


The program is similar to Figure 2.5, but the programmer specified that the two print statements in a thread should be executed as an atomic unit.

நிரல் படம் 2.5 ஐப் போன்றது, ஆனால் ஒரு திரெட்டில் உள்ள இரண்டு பிரிண்ட் அறிக்கைகள் ஒரு அணு அலகு போல செயல்படுத்தப்பட வேண்டும் என்று நிரலாளர் குறிப்பிட்டிருக்கிறார்.


As a result, there are only two interleavings possible.

இதன் விளைவாக, இரண்டு இடைவெளிகள் மட்டுமே சாத்தியமாகும்.


Harmony does not support floating point.

ஹார்மனி மிதக்கும் புள்ளியை ஆதரிக்காது.


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

பைத்தானில், பட்டியல்கள், அகராதிகள் மற்றும் தொகுப்புகள் (மாற்றக்கூடிய) பொருள்கள். ஹார்மனியில், அவை (மாறாத) மதிப்புகள்.


The method declares a variable called result that eventually contains the result of the method.

இந்த முறை result எனப்படும் ஒரு மாறியை அறிவிக்கிறது, இது இறுதியில் முறையின் முடிவைக் கொண்டிருக்கும்.


The {x..y} notation represents a set containing the numbers from x to y (inclusive).

{x..y} என்ற குறியீடு x முதல் y வரையிலான எண்களைக் கொண்ட ஒரு தொகுப்பைக் குறிக்கிறது (உள்ளடக்கியது).


Running this Harmony program will try all possible executions, which includes all possible values for x.

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


The results from running the Harmony model checker are output in Markdown format.

ஹார்மனி மாதிரி சரிபார்ப்பை இயக்குவதன் முடிவுகள் Markdown வடிவத்தில் வெளியீடு செய்யப்படுகின்றன.


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

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


In Harmony, 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 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.

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


If the threads run one at a time to completion, then x will be incremented twice and ends up being 2.

திரெட்கள் ஒவ்வொன்றாக முடிவடையும் வரை இயங்கினால், x இரண்டு முறை அதிகரிக்கும், மேலும் அது 2 ஆக முடிவடையும்.


இது ஒரு பந்தய நிலை என்று அழைக்கப்படுகிறது.


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

ஹார்மனியுடன் ஒரு நிரலை இயக்கும்போது, அது கூற்றுகளின் மீறல்களைப் புகாரளிக்கும்.


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)


Deterministically triggering bugs allows you to find bugs in your concurrent programs much more easily than using a conventional programming environment.

கண்டிப்பாக பிழைகளைத் தூண்டுவது, வழக்கமான நிரலாக்க சூழலைப் பயன்படுத்துவதை விட, உங்கள் ஒரே நேரத்தில் இயங்கும் நிரல்களில் பிழைகளைக் கண்டறிய உங்களை அனுமதிக்கிறது.


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)?

கூற்று எத்தனை முறை தோல்வியடைகிறது (ஏதேனும் இருந்தால்)?


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

கூற்று எத்தனை முறை தோல்வியடைந்தது என்பதையும், தோல்வியுற்ற ஒவ்வொரு இயக்கத்திற்கும் x இன் மதிப்பு என்னவாக இருந்தது என்பதையும் தெரிவிக்கவும்.


The Harmony compiler, harmony, places the bytecode for file x.hny in file x.hvm.

ஹார்மனி கம்பைலர், ஹார்மனி, x.hny கோப்பிற்கான பைட்கோடை x.hvm கோப்பில் வைக்கிறது.


ஹார்மனி மதிப்புகள் மீண்டும் மீண்டும் வரையறுக்கப்படுகின்றன.


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.

ஒரு எழுத்து அல்லது அடிக்கோட்டில் தொடங்கி, எழுத்துக்கள், இலக்கங்கள் மற்றும் அடிக்கோடுகளை மட்டுமே கொண்ட சரங்களை, ஒரு புள்ளியுடன் முன்னொட்டு செய்வதன் மூலம் மேற்கோள்கள் இல்லாமல் எழுதலாம்.


Dictionaries are written as {k 0 : v 0 , k 1 :v 1 , ...}.

அகராதிகள் {k 0 : v 0 , k 1 :v 1 , ...} என எழுதப்படுகின்றன.


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

பகிர்ந்த நினைவகம் என்பது சரங்களை (பகிர்ந்த மாறிகளின் பெயர்கள்) மற்ற ஹார்மனி மதிப்புகளுக்கு மேப் செய்யும் ஒரு அகராதி ஆகும்.


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 company announced its quarterly results.

நிறுவனம் அதன் காலாண்டு முடிவுகளை அறிவித்தது.


அவர் மிகவும் திறமையான இசைக்கலைஞர்.


The new software update has several bug fixes.

புதிய மென்பொருள் புதுப்பிப்பில் பல பிழை திருத்தங்கள் உள்ளன.


The government is implementing new policies.

அரசாங்கம் புதிய கொள்கைகளை அமல்படுத்துகிறது.


She enjoys reading novels in her free time.

அவள் ஓய்வு நேரத்தில் நாவல்கள் படிப்பதை விரும்புகிறாள்.


The research team is working on a new project.

ஆராய்ச்சி குழு ஒரு புதிய திட்டத்தில் வேலை செய்கிறது.


The economic situation is improving gradually.

பொருளாதார நிலை படிப்படியாக மேம்பட்டு வருகிறது.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


சவால்கள் இருந்தபோதிலும், அவர்கள் வெற்றி பெற்றனர்.


மாநாடு அடுத்த மாதம் நடைபெறும்.


The company's stock price increased significantly.

நிறுவனத்தின் பங்கு விலை கணிசமாக உயர்ந்தது.


அவர் தனது துறையில் புகழ்பெற்ற நிபுணர்.


The system requires a complete overhaul.

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


The implications of the decision are far-reaching.

இந்த முடிவின் விளைவுகள் தொலைநோக்குடையவை.


அவள் பல மொழிகளில் சரளமாக பேசுகிறாள்.


The project's deadline is approaching rapidly.

திட்டத்தின் காலக்கெடு வேகமாக நெருங்குகிறது.


The complex equation was finally solved.

சிக்கலான சமன்பாடு இறுதியாக தீர்க்கப்பட்டது.


The code uses locks to prevent race conditions.

போட்டி நிலைகளைத் தவிர்க்க குறியீடு பூட்டுகளைப் பயன்படுத்துகிறது.


Threads can access shared data structures safely using critical sections.

முக்கியமான பிரிவுகளைப் பயன்படுத்தி நூல்கள் பாதுகாப்பாக பகிரப்பட்ட தரவு கட்டமைப்புகளை அணுகலாம்.


The program implements a reader/writer lock to allow concurrent access.

நிரல் ஒரே நேரத்தில் அணுகலை அனுமதிக்க ரீடர்/ரைட்டர் பூட்டை செயல்படுத்துகிறது.


Condition variables are used for efficient conditional waiting.

திறமையான நிபந்தனை காத்திருப்புக்கு நிபந்தனை மாறிகள் பயன்படுத்தப்படுகின்றன.


A bounded buffer is a queue with a fixed maximum size.

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


The producer/consumer problem is a classic synchronization challenge.

உற்பத்தியாளர்/நுகர்வோர் பிரச்சனை ஒரு உன்னதமான ஒத்திசைவு சவாலாகும்.


Starvation can occur when a thread is repeatedly denied access.

ஒரு நூல் மீண்டும் மீண்டும் அணுகலை மறுக்கும்போது பட்டினி ஏற்படலாம்.


Deadlock happens when threads are blocked indefinitely.

நூல்கள் காலவரையின்றி தடுக்கப்படும்போது முட்டுக்கட்டை ஏற்படுகிறது.


The program uses a mutex to protect shared resources.

பகிரப்பட்ட வளங்களைப் பாதுகாக்க நிரல் ஒரு மியூட்டெக்ஸைப் பயன்படுத்துகிறது.


அல்காரிதம் பரஸ்பர விலக்கலை உறுதி செய்கிறது.


The system prevents race conditions by using locks.

பூட்டுகளைப் பயன்படுத்துவதன் மூலம் அமைப்பு போட்டி நிலைகளைத் தடுக்கிறது.


குறியீடு நூல்-பாதுகாப்பாக வடிவமைக்கப்பட்டுள்ளது.


The program uses condition variables for synchronization.

ஒத்திசைவுக்காக நிரல் நிபந்தனை மாறிகளைப் பயன்படுத்துகிறது.


செயல்படுத்துதல் பிஸியாக காத்திருப்பதைத் தவிர்க்கிறது.


The system provides a fair scheduling mechanism.

அமைப்பு ஒரு நியாயமான திட்டமிடல் வழிமுறையை வழங்குகிறது.


The application is designed to handle concurrent requests.

பயன்பாடு ஒரே நேரத்தில் வரும் கோரிக்கைகளைக் கையாள வடிவமைக்கப்பட்டுள்ளது.


The software uses a bounded buffer to manage data flow.

தரவு ஓட்டத்தை நிர்வகிக்க மென்பொருள் ஒரு வரையறுக்கப்பட்ட இடையகத்தைப் பயன்படுத்துகிறது.


The critical section ensures data consistency.

முக்கியமான பிரிவு தரவு நிலைத்தன்மையை உறுதி செய்கிறது.


The program's performance is optimized for multi-threading.

நிரலின் செயல்திறன் பல-நூல் செயலாக்கத்திற்காக உகந்ததாக உள்ளது.


The system prevents deadlock by using a specific locking order.

ஒரு குறிப்பிட்ட பூட்டுதல் வரிசையைப் பயன்படுத்துவதன் மூலம் அமைப்பு முட்டுக்கட்டையைத் தடுக்கிறது.


The file system uses worker threads for file operations.

கோப்பு முறைமை கோப்பு செயல்பாடுகளுக்கு பணியாளர் நூல்களைப் பயன்படுத்துகிறது.


Each block is identified by its offset or block number.

ஒவ்வொரு தொகுதியும் அதன் ஆஃப்செட் அல்லது தொகுதி எண்ணால் அடையாளம் காணப்படுகிறது.


The file system interface is similar to Unix-like systems.

கோப்பு முறைமை இடைமுகம் யூனிக்ஸ் போன்ற அமைப்புகளை ஒத்திருக்கிறது.


The system uses reader/writer locks for inode blocks.

இந்த அமைப்பு ஐனோட் தொகுதிகளுக்கு ரீடர்/ரைட்டர் பூட்டுகளைப் பயன்படுத்துகிறது.


The worker threads handle client requests.

பணியாளர் நூல்கள் வாடிக்கையாளர் கோரிக்கைகளை கையாளுகின்றன.


The disk is an array of blocks of fixed length.

வட்டு என்பது நிலையான நீளத்தின் தொகுதிகளின் வரிசையாகும்.


The superblock specifies the number of inode blocks.

சூப்பர் பிளாக் ஐனோட் தொகுதிகளின் எண்ணிக்கையை குறிப்பிடுகிறது.


The file system data structure is essentially a tree of blocks.

கோப்பு முறைமை தரவு கட்டமைப்பு அடிப்படையில் தொகுதிகளின் ஒரு மரமாகும்.


The implementation uses the actor model.

செயல்படுத்துதல் நடிகர் மாதிரியைப் பயன்படுத்துகிறது.


The request queue has concurrent producers and consumers.

கோரிக்கை வரிசையில் ஒரே நேரத்தில் தயாரிப்பாளர்கள் மற்றும் நுகர்வோர் உள்ளனர்.


The response queues are single use only.

பதிலளிப்பு வரிசைகள் ஒரே பயன்பாட்டிற்கு மட்டுமே.


Each worker thread executes an infinite loop.

ஒவ்வொரு பணியாளர் நூலும் ஒரு முடிவிலா சுழற்சியை இயக்குகிறது.


The method first needs to read the block that contains the inode.

இந்த முறை முதலில் ஐனோட் கொண்டிருக்கும் தொகுதியை படிக்க வேண்டும்.


Handling a read request depends on the offset.

ஒரு ரீட் கோரிக்கையை கையாளுவது ஆஃப்செட்டைப் பொறுத்தது.


The write operation checks if the direct block is updated.

எழுதுதல் செயல்பாடு நேரடி தொகுதி புதுப்பிக்கப்பட்டதா என சரிபார்க்கிறது.


Deleting a file puts all its blocks back on the free list.

ஒரு கோப்பை நீக்குவது அதன் அனைத்து தொகுதிகளையும் இலவச பட்டியலில் மீண்டும் வைக்கிறது.


An interrupt is a notification, while an exception is an error.

ஒரு குறுக்கீடு என்பது ஒரு அறிவிப்பு, அதே நேரத்தில் ஒரு விதிவிலக்கு ஒரு பிழை.


Locks are intended to solve synchronization issues between multiple threads.

பூட்டுகள் பல நூல்களுக்கு இடையே ஒத்திசைவு சிக்கல்களை தீர்க்க வடிவமைக்கப்பட்டுள்ளன.


The code in Figure 20.2 is not interrupt-safe.

படம் 20.2 இல் உள்ள குறியீடு குறுக்கீடு-பாதுகாப்பானது அல்ல.


It is important that the main code re-enables interrupts.

முக்கிய குறியீடு குறுக்கீடுகளை மீண்டும் இயக்குவது முக்கியம்.


Alice sends application messages in a specific order.

ஆலிஸ் பயன்பாட்டு செய்திகளை ஒரு குறிப்பிட்ட வரிசையில் அனுப்புகிறார்.


Bob receives messages, and unless it's the first, he's already received the previous ones.

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


The Alternating Bit Protocol is suitable for our purposes.

மாற்று பிட் நெறிமுறை நமது நோக்கங்களுக்காகப் பொருத்தமானது.


Alice and Bob each maintain a sequence number.

ஆலிஸும், பாபும் தலா ஒரு வரிசை எண்ணை பராமரிக்கிறார்கள்.


ஆலிஸ் பாப்பிற்கு ஒரு பிணைய செய்தியை அனுப்புகிறார்.


பாப் ஆலிஸிற்கு ஒரு ஒப்புதலைத் திருப்பி அனுப்புகிறார்.


Alice keeps sending the same network message until she receives an acknowledgment.

ஆலிஸ் ஒரு ஒப்புதலைப் பெறும் வரை அதே பிணைய செய்தியை அனுப்பிக் கொண்டே இருப்பாள்.


இது மீண்டும் அனுப்புதல் என்று அழைக்கப்படுகிறது.


Bob waits until he receives a message matching Bob’s sequence number.

பாப், பாப்பின் வரிசை எண்ணுடன் பொருந்தும் ஒரு செய்தியைப் பெறும் வரை காத்திருப்பார்.


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

பிணைய பண்புகளின் காரணமாக, ஒரு-பிட் வரிசை எண் போதுமானது.


We can model each channel as a variable.

ஒவ்வொரு சேனலையும் ஒரு மாறியாக நாம் மாதிரியாக உருவாக்கலாம்.


The method places either m or () in !pchan.

இந்த முறை m அல்லது () ஐ !pchan இல் வைக்கிறது.


Method appsend retransmits until an acknowledgment is received.

appsend முறை ஒரு ஒப்புதல் பெறப்படும் வரை மீண்டும் அனுப்புகிறது.


Method apprecv returns the next successfully received message.

apprecv முறை அடுத்த வெற்றிகரமாக பெறப்பட்ட செய்தியை வழங்குகிறது.


Figure 22.2 shows how the methods may be used.

படம் 22.2 இந்த முறைகளை எவ்வாறு பயன்படுத்தலாம் என்பதைக் காட்டுகிறது.


செய்திகளின் எண்ணிக்கை கட்டுப்படுத்தப்பட வேண்டும்.


The receiver is spawned as eternal because it does not terminate.

பெறுநர் முடிவடையாததால், எப்போதும் இயங்கும்படி உருவாக்கப்படுகிறது.


Develop a protocol for a single client and server.

ஒரு கிளையன்ட் மற்றும் சேவையகத்திற்கான ஒரு நெறிமுறையை உருவாக்குங்கள்.


Generalize the solution to multiple clients.

பல கிளையண்டுகளுக்கு தீர்வை பொதுமைப்படுத்துங்கள்.


ஒவ்வொரு கிளையண்ட்டும் தனித்துவமாக அடையாளம் காணப்படுகிறார்கள்.


Imagine five philosopers sitting around a table, each with a plate of food in front of them and a fork between every two plates.

ஐந்து தத்துவஞானிகள் ஒரு மேசையில் அமர்ந்திருப்பதை கற்பனை செய்து பாருங்கள், ஒவ்வொருவருக்கும் முன் ஒரு தட்டு உணவு மற்றும் ஒவ்வொரு இரண்டு தட்டுகளுக்கும் இடையில் ஒரு முட்கரண்டி உள்ளது.


Each philosopher requires two forks to eat.

ஒவ்வொரு தத்துவஞானியும் சாப்பிட இரண்டு முட்கரண்டிகள் தேவை.


To start eating, a philosopher first picks up the fork on the left, then the fork on the right.

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


Each philosopher likes to take breaks from eating to think for a while.

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


To do so, the philosopher puts down both forks.

அவ்வாறு செய்ய, தத்துவஞானி இரண்டு முட்கரண்டிகளையும் கீழே வைக்கிறார்.


Each philosopher repeats this procedure.

ஒவ்வொரு தத்துவஞானியும் இந்த நடைமுறையை மீண்டும் செய்கிறார்கள்.


Dijkstra had them repeating this for ever, but for the purposes of this book, philosophers can—if they wish—leave the table when they are not using any forks.

டிக்ஸ்ட்ரா இதை எப்போதும் மீண்டும் செய்யச் சொன்னார், ஆனால் இந்தப் புத்தகத்தின் நோக்கங்களுக்காக, தத்துவஞானிகள் விரும்பினால், எந்த முட்கரண்டிகளையும் பயன்படுத்தாதபோது மேசையை விட்டு வெளியேறலாம்.


If you run it, Harmony complains that the execution may not be able to terminate, with all five threads being blocked trying to acquire the lock.

நீங்கள் அதை இயக்கும்போது, ஐந்து திரிகளும் பூட்டுகளைப் பெற முயற்சிப்பதால், செயல்படுத்தல் நிறுத்தப்படாமல் போகலாம் என்று ஹார்மனி புகார் செய்கிறது.


பிரச்சனை என்னவென்று புரிகிறதா?


Does it depend on N, the number of philosophers?

இது தத்துவஞானிகளின் எண்ணிக்கையான N ஐப் பொறுத்து உள்ளதா?


There are four conditions that must hold for deadlock to occur, sometimes known as the Coffman Conditions.

முட்டுக்கட்டை ஏற்பட நான்கு நிபந்தனைகள் இருக்க வேண்டும், சில நேரங்களில் காஃப்மேன் நிபந்தனைகள் என்று அழைக்கப்படுகின்றன.


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

பரஸ்பர விலக்கு: ஒவ்வொரு வளமும் ஒரு நேரத்தில் ஒரு திரியால் மட்டுமே பயன்படுத்த முடியும்.


Hold and Wait: each thread holds resources it already allocated while it waits for other resources that it needs.

பிடித்துக் காத்திரு: ஒவ்வொரு திரியும் ஏற்கனவே ஒதுக்கப்பட்ட வளங்களை வைத்திருக்கிறது, அதே நேரத்தில் அதற்குத் தேவையான மற்ற வளங்களுக்காகக் காத்திருக்கிறது.


No Preemption: resources cannot be forcibly taken away from threads that allocated them.

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


Circular Wait: there exists a directed circular chain of threads, each waiting to allocate a resource held by the next.

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


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

எனவே முட்டுக்கட்டையைத் தடுப்பது, இந்த நிபந்தனைகளில் ஒன்று ஏற்படுவதைத் தடுப்பதைக் குறிக்கிறது.


However, mutual exclusion is not easily prevented in general because many resources allow only one process to use it at a time.

இருப்பினும், பொதுவில் பரஸ்பர விலக்கு எளிதில் தடுக்கப்படுவதில்லை, ஏனெனில் பல வளங்கள் ஒரு நேரத்தில் ஒரு செயல்முறையை மட்டுமே பயன்படுத்த அனுமதிக்கின்றன.


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.

ஹோல்ட் மற்றும் வெயிட் தீர்வு செயல்படுத்த, ஒரு தத்துவஞானி ஒரே நேரத்தில் இடது மற்றும் வலது முட்கரண்டிகளையும் பூட்டுவதற்கான ஒரு வழியைக் கொண்டிருக்க வேண்டும்.


Locks do not have such an ability, so we re-implement the Dining Philosophers using condition variables that allow one to wait for arbitrary application- specific conditions.

பூட்டுகளுக்கு அத்தகைய திறன் இல்லை, எனவே தன்னிச்சையான பயன்பாட்டு-குறிப்பிட்ட நிபந்தனைகளுக்காகக் காத்திருக்க அனுமதிக்கும் நிபந்தனை மாறிகளைப் பயன்படுத்தி டைனிங் தத்துவஞானிகளை மீண்டும் செயல்படுத்துகிறோம்.


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.

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


Next, 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 counterdeliveredthat counts the number of delivered requests.

இதற்காக, வழங்கப்பட்ட கோரிக்கைகளின் எண்ணிக்கையை எண்ணும் ஒரு counterdeliveredthat ஐப் பராமரிக்கிறது.


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 of Figure 25.1.

சங்கிலி பிரதிபலிப்பு, படம் 25.1 இன் பிரதிபலித்த மாநில இயந்திர விவரக்குறிப்பைப் போலவே செயல்படுகிறதா என்பதுதான் கேள்வி.


This can be checked using the following two Harmony commands: $ harmony -o rsm.hfa code/rsm.hny $ harmony -B rsm.hfa code/chain.hny

இதை பின்வரும் இரண்டு ஹார்மனி கட்டளைகளைப் பயன்படுத்தி சரிபார்க்கலாம்: $ harmony -o rsm.hfa code/rsm.hny $ harmony -B rsm.hfa code/chain.hny


The first command outputs the behavior DFA ofcode/rsm.hnyin the filersm.hfa.

முதல் கட்டளை filersm.hfa இல் code/rsm.hny இன் நடத்தை DFA ஐ வெளியிடுகிறது.


The second command checks that the behavior ofcode/chain.hnysatisfies the DFA inrsm.hfa.

இரண்டாவது கட்டளை code/chain.hny இன் நடத்தை rsm.hfa இல் உள்ள 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 selects the proposal with the highest ballot number.

தலைவர் அதிக வாக்கு எண்ணைக் கொண்ட முன்மொழிவைத் தேர்ந்தெடுக்கிறார்.


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

ஆலிஸ் ஒரு புதிய நான்ஸ் NA ஐ உருவாக்கி அதை பாப்பிற்கு அனுப்புகிறார்.


The protocol is used for authentication in large networks.

இந்த நெறிமுறை பெரிய நெட்வொர்க்குகளில் அங்கீகாரத்திற்காகப் பயன்படுத்தப்படுகிறது.


Corey tries to find an attack by sending messages.

செய்திகளை அனுப்புவதன் மூலம் கோரி ஒரு தாக்குதலைக் கண்டுபிடிக்க முயற்சிக்கிறார்.


Bob only accepts connections with Alice.

பாப், ஆலிஸுடன் மட்டுமே இணைப்புகளை ஏற்றுக்கொள்கிறார்.


The security property is violated in this scenario.

பாதுகாப்பு சொத்து இந்த சூழ்நிலையில் மீறப்படுகிறது.


Model checking can be used to find the bug.

பிழையைக் கண்டறிய மாதிரி சரிபார்ப்பைப் பயன்படுத்தலாம்.


Alice and Bob are both honest in this protocol.

இந்த நெறிமுறையில் ஆலிஸும், பாப்பும் நேர்மையானவர்கள்.


The Needham-Schroeder protocol has a security flaw.

நீட்ஹாம்-ஷ்ரோடர் நெறிமுறை ஒரு பாதுகாப்பு குறைபாட்டைக் கொண்டுள்ளது.


The attack involves a third party named Corey.

இந்த தாக்குதலில் கோரி என்ற மூன்றாம் தரப்பு ஈடுபட்டுள்ளது.


The code for Alice and Bob follows the steps.

ஆலிஸ் மற்றும் பாப்பிற்கான குறியீடு படிகளைப் பின்பற்றுகிறது.


The protocol was found to be incorrect after 17 years.

17 ஆண்டுகளுக்குப் பிறகு இந்த நெறிமுறை தவறானது என்று கண்டறியப்பட்டது.


கோரி, பாப்பிடம் ஆலிஸாக நடிக்க முடியும்.


The protocol uses public key cryptography.

இந்த நெறிமுறை பொது சாவி மறைக்குறியீட்டைப் பயன்படுத்துகிறது.


The message is encrypted for a particular destination.

செய்தி ஒரு குறிப்பிட்ட இலக்குக்காக மறையாக்கம் செய்யப்பட்டுள்ளது.


ஆலிஸ் ஒரு புதிய நான்ஸை உருவாக்குகிறார்.


பாப் ஒரு புதிய நான்ஸ் NB ஐ உருவாக்குகிறார்.


இந்த நெறிமுறை மூன்று முக்கியமான படிகளைக் கொண்டுள்ளது.


குறியீடு பிழையை நிரூபிக்கிறது.


பாதுகாப்பு பண்புகள் சமச்சீராக உள்ளன.


இன்று சூரியன் பிரகாசமாக பிரகாசிக்கிறது.


உப்பு கொஞ்சம் கொடுங்களேன்?


The company announced a new product launch.

நிறுவனம் ஒரு புதிய தயாரிப்பு வெளியீட்டை அறிவித்தது.


He is studying for his exams diligently.

அவர் தனது தேர்வுகளுக்காக விடாமுயற்சியுடன் படித்து வருகிறார்.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


The government implemented new policies.

அரசு புதிய கொள்கைகளை அமல்படுத்தியது.


She enjoys reading novels in her free time.

அவள் தனது ஓய்வு நேரத்தில் நாவல்கள் படிப்பதை விரும்புகிறாள்.


The research paper explores various aspects of climate change.

இந்த ஆராய்ச்சி கட்டுரை காலநிலை மாற்றத்தின் பல்வேறு அம்சங்களை ஆராய்கிறது.


ரயில் சரியான நேரத்தில் வந்தது.


Please turn off the lights before you leave.

நீங்கள் வெளியே செல்வதற்கு முன் விளக்குகளை அணைக்கவும்.


The stock market experienced a significant downturn.

பங்குச் சந்தை குறிப்பிடத்தக்க சரிவை சந்தித்தது.


He is a highly skilled software engineer.

அவர் ஒரு திறமையான மென்பொருள் பொறியாளர்.


The complex equation requires careful analysis.

சிக்கலான சமன்பாடு கவனமாக பகுப்பாய்வு செய்யப்பட வேண்டும்.


மாநாடு அடுத்த மாதம் நடைபெறும்.


அவள் ஒரு திறமையான இசைக்கலைஞர்.


The data analysis revealed interesting patterns.

தரவு பகுப்பாய்வு சுவாரஸ்யமான வடிவங்களை வெளிப்படுத்தியது.


திட்டம் திட்டமிட்டபடி முடிக்கப்பட்டது.


தயவுசெய்து அதை மீண்டும் சொல்ல முடியுமா?


பொருளாதார முன்னறிவிப்பு வளர்ச்சியை முன்னறிவிக்கிறது.


The intricate design showcases the artist's skill.

சிக்கலான வடிவமைப்பு கலைஞரின் திறமையை வெளிப்படுத்துகிறது.


The program uses bytecode addresses for methods and lambdas.

நிரல் முறைகள் மற்றும் லாம்ப்டாக்களுக்கான பைட்கோட் முகவரிகளைப் பயன்படுத்துகிறது.


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

ஒரு வாதத்துடன் கூடிய ஒரு முறைக்கு தாமதமான அழைப்பு ஒரு தங்கு மூலம் குறிக்கப்படுகிறது.


Harmony uses the address of a method variable internally.

ஹார்மனி உள்நாட்டில் ஒரு முறை மாறியின் முகவரியைப் பயன்படுத்துகிறது.


The save expression returns a tuple with the context value.

சேமிப்பு வெளிப்பாடு சூழல் மதிப்பைக் கொண்ட ஒரு டியூப்பிளை வழங்குகிறது.


சூழல் ஒரு திரையின் நிலையை கைப்பற்றுகிறது.


The statement 'x = 3' assigns the value 3 to variable x.

'x = 3' என்ற அறிக்கை மாறி x க்கு 3 என்ற மதிப்பை ஒதுக்குகிறது.


The statement 'x += 3' loads x, adds 3, and stores the result in x.

'x += 3' என்ற அறிக்கை x ஐ ஏற்றுகிறது, 3 ஐ சேர்க்கிறது, மேலும் முடிவை x இல் சேமிக்கிறது.


The assert statement reports an error if the boolean expression is false.

பூலியன் வெளிப்பாடு தவறாக இருந்தால், உறுதி அறிக்கை ஒரு பிழையைப் புகாரளிக்கிறது.


A statement can be made atomic using the 'atomically' keyword.

'அணுசக்தியில்' என்ற முக்கிய வார்த்தையைப் பயன்படுத்தி ஒரு அறிக்கையை அணுசக்தியாக மாற்றலாம்.


The 'await' statement is equivalent to 'when b: pass'.

'காத்திரு' அறிக்கை 'எப்போது b: கடந்து செல்' என்பதற்கு சமம்.


The const expression introduces a new constant with a value.

const வெளிப்பாடு ஒரு மதிப்பைக் கொண்ட ஒரு புதிய மாறிலியை அறிமுகப்படுத்துகிறது.


The def statement defines a new bytecode address constant.

def அறிக்கை ஒரு புதிய பைட்கோட் முகவரி மாறிலியை வரையறுக்கிறது.


The del statement removes a variable from the state.

del அறிக்கை ஒரு மாறியை நிலையிலிருந்து நீக்குகிறது.


The for...in... statement iterates over a set, list, dictionary, or string.

for...in... அறிக்கை ஒரு தொகுப்பு, பட்டியல், அகராதி அல்லது சரத்தை மீண்டும் செய்கிறது.


The global statement tells the compiler that the variables are shared.

உலகளாவிய அறிக்கை மாறிகள் பகிரப்படுகின்றன என்று தொகுப்பாளரிடம் கூறுகிறது.


The go statement starts a thread with a context.

go அறிக்கை ஒரு சூழலுடன் ஒரு திரையைத் தொடங்குகிறது.


The if statement supports conditional execution.

if அறிக்கை நிபந்தனை செயல்படுத்தலை ஆதரிக்கிறது.


The invariant statement declares a boolean expression as an invariant.

மாறிலி அறிக்கை ஒரு பூலியன் வெளிப்பாட்டை ஒரு மாறிலியாக அறிவிக்கிறது.


You can introduce new bound variables using the let statement.

நீங்கள் let அறிக்கையைப் பயன்படுத்தி புதிய கட்டுப்படுத்தப்பட்ட மாறிகளை அறிமுகப்படுத்தலாம்.


The print statement adds the result of an expression to the print log.

print அறிக்கை ஒரு வெளிப்பாட்டின் முடிவை அச்சுப் பதிவேட்டில் சேர்க்கிறது.


The Harmony compiler and model checker are used for verifying the correctness of concurrent programs.

சமாந்தர நிரல்களை சரிபார்க்க ஹார்மனி கம்பைலரும், மாடல் செக்கரும் பயன்படுத்தப்படுகின்றன.


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

பரஸ்பர விலக்கு சிக்கலுக்கு பீட்டர்சனின் அல்காரிதம் ஒரு தீர்வை வழங்குகிறது.


Inductive invariants are crucial for proving the correctness of concurrent algorithms.

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


The program uses a queue implementation with linearization points.

நிரல் வரிசைப்படுத்தல் புள்ளிகளுடன் கூடிய வரிசை செயலாக்கத்தைப் பயன்படுத்துகிறது.


Concurrency testing involves executing operations concurrently.

சமாந்தர சோதனை என்பது செயல்பாடுகளை ஒரே நேரத்தில் செயல்படுத்துவதை உள்ளடக்கியது.


The test program starts a thread for each operation.

சோதனை நிரல் ஒவ்வொரு செயல்பாட்டிற்கும் ஒரு திரையைத் தொடங்குகிறது.


The Harmony compiler generates bytecode.

ஹார்மனி கம்பைலர் பைட்கோடை உருவாக்குகிறது.


The model checker analyzes the bytecode for errors.

மாடல் செக்கர் பிழைகளுக்காக பைட்கோடை பகுப்பாய்வு செய்கிறது.


The program checks for safety violations.

நிரல் பாதுகாப்பு மீறல்களை சரிபார்க்கிறது.


அமைப்பு பந்தய நிலைமைகளைக் கண்டறிகிறது.


The Harmony compiler has different output file options.

ஹார்மனி கம்பைலரில் வெவ்வேறு வெளியீட்டு கோப்பு விருப்பங்கள் உள்ளன.


The -ofilename.hco option specifies the model checker output file.

-ofilename.hco விருப்பம் மாடல் செக்கர் வெளியீட்டு கோப்பை குறிப்பிடுகிறது.


நிரல் ஒரு பகிரப்பட்ட வரிசையைப் பயன்படுத்துகிறது.


The algorithm uses locks to protect critical sections.

முக்கியப் பகுதிகளைப் பாதுகாக்க வழிமுறை பூட்டுகளைப் பயன்படுத்துகிறது.


The code implements a reader/writer lock.

குறியீடு ரீடர்/ரைட்டர் பூட்டை செயல்படுத்துகிறது.


Split Binary Semaphores are used for conditional waiting.

நிபந்தனை காத்திருப்புக்கு ஸ்பிளிட் பைனரி செமாபோர்கள் பயன்படுத்தப்படுகின்றன.


The main gate is implemented by a binary semaphore.

முக்கிய வாயில் ஒரு பைனரி செமாபோரால் செயல்படுத்தப்படுகிறது.


நிரல் ஹோரே மானிட்டர்களைப் பயன்படுத்துகிறது.


ஒரு மானிட்டரில் நிபந்தனை மாறிகள் உள்ளன.


The bounded buffer problem is addressed.

வரையறுக்கப்பட்ட இடையக சிக்கல் தீர்க்கப்படுகிறது.


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

இந்த நிரல் தயாரிப்பாளர்களுக்கும் நுகர்வோர்களுக்கும் இடையே தரவு ஓட்டத்தை நிர்வகிக்க ஒரு வரம்புக்குட்பட்ட இடையகத்தைப் பயன்படுத்துகிறது.


Hoare monitors provide a mechanism for thread synchronization.

ஹோரே மானிட்டர்கள் திரெட் ஒத்திசைவுக்கான ஒரு வழிமுறையை வழங்குகின்றன.


A bounded buffer prevents producers from overwhelming consumers.

வரையறுக்கப்பட்ட இடையகம் தயாரிப்பாளர்கள் நுகர்வோரை மிகைப்படுத்துவதைத் தடுக்கிறது.


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

இந்த குறியீடு பிளவு இரும செமாபோர்களைப் பயன்படுத்தி தயாரிப்பாளர்-நுகர்வோர் சிக்கலை செயல்படுத்துகிறது.


Mutual exclusion is crucial for protecting shared resources.

பகிர்ந்த வளங்களைப் பாதுகாப்பதற்கு பரஸ்பர விலக்கு இன்றியமையாதது.


The program uses locks to ensure data consistency.

தரவு நிலைத்தன்மையை உறுதிப்படுத்த இந்த நிரல் பூட்டுகளைப் பயன்படுத்துகிறது.


Threads can be blocked while waiting for a condition.

ஒரு நிபந்தனைக்காகக் காத்திருக்கும்போது திரெட்கள் தடுக்கப்படலாம்.


The concept of atomicity is essential in concurrent programming.

ஒருங்கிணைந்த நிரலாக்கத்தில் அணுசக்தி என்ற கருத்து இன்றியமையாதது.


Deadlocks can occur if threads are not managed carefully.

திரெட்களை கவனமாக நிர்வகிக்காவிட்டால் முட்டுக்கட்டைகள் ஏற்படலாம்.


Fairness is an important consideration in thread scheduling.

திரெட் திட்டமிடலில் நியாயம் ஒரு முக்கியமான கருத்தாகும்.


The program uses a monitor to synchronize access to a shared resource.

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


A reader-writer lock allows multiple readers or a single writer.

ஒரு ரீடர்-ரைட்டர் பூட்டு பல வாசகர்கள் அல்லது ஒரு எழுத்தாளரை அனுமதிக்கிறது.


The code demonstrates the use of a spinlock.

இந்த குறியீடு ஸ்பின்லாக்கின் பயன்பாட்டை விளக்குகிறது.


Concurrency can improve performance in certain scenarios.

சில சூழ்நிலைகளில் ஒருங்கிசைவு செயல்திறனை மேம்படுத்தும்.


The program avoids data races by using appropriate synchronization primitives.

சரியான ஒத்திசைவு பிரைமிடிவ்களைப் பயன்படுத்துவதன் மூலம் இந்த நிரல் தரவுப் பந்தயங்களைத் தவிர்க்கிறது.


Understanding thread safety is crucial for writing robust concurrent programs.

வலுவான ஒருங்கிசைவான நிரல்களை எழுதுவதற்கு திரெட் பாதுகாப்பை புரிந்துகொள்வது அவசியம்.


The implementation uses a bounded buffer to prevent the producer from overwhelming the consumer.

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


The Hoare monitor implementation uses condition variables for thread coordination.

ஹோரே மானிட்டர் செயல்படுத்தல் திரெட் ஒருங்கிணைப்புக்காக நிபந்தனை மாறிகளைப் பயன்படுத்துகிறது.


Careful consideration of potential deadlocks is essential when designing concurrent systems.

ஒருங்கிணைந்த அமைப்புகளை வடிவமைக்கும்போது, சாத்தியமான முட்டுக்கட்டைகளை கவனமாக பரிசீலிப்பது அவசியம்.


The program's design prioritizes fairness to prevent thread starvation.

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