ಪರ್ಯಾಯ ಬಿಟ್ ಪ್ರೋಟೋಕಾಲ್.


ಪರ್ಯಾಯ ಬಿಟ್ ಪ್ರೋಟೋಕಾಲ್‌ಗಾಗಿ ಪರೀಕ್ಷಾ ಕೋಡ್.


ರಿಂಗ್‌ನಲ್ಲಿ ಲೀಡರ್ ಚುನಾವಣಾ ಪ್ರೋಟೋಕಾಲ್.


Two Phase Commit protocol: code for banks.

ಎರಡು ಹಂತದ ಕಮಿಟ್ ಪ್ರೋಟೋಕಾಲ್: ಬ್ಯಾಂಕುಗಳಿಗಾಗಿ ಕೋಡ್.


Two Phase Commit protocol: code for transaction coordinators.

ಎರಡು ಹಂತದ ಕಮಿಟ್ ಪ್ರೋಟೋಕಾಲ್: ವಹಿವಾಟು ಸಮನ್ವಯಕಾರರಿಗಾಗಿ ಕೋಡ್.


ಪ್ರತಿಕೃತಿ ಸ್ಥಿತಿ ಯಂತ್ರ.


The DFA generated by Figure 25.1 when NOPS=2 and NREPLICAS=2.

ಚಿತ್ರ 25.1 ರಿಂದ ಉತ್ಪತ್ತಿಯಾದ DFA, NOPS=2 ಮತ್ತು NREPLICAS=2 ಇರುವಾಗ.


ಸರಪಳಿ ಪ್ರತಿಕೃತಿ (ಭಾಗ 1).


ಸರಪಳಿ ಪ್ರತಿಕೃತಿ (ಭಾಗ 2).


Chain Replication specification using actions (part 1).

ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸರಪಳಿ ಪ್ರತಿಕೃತಿ ವಿವರಣೆ (ಭಾಗ 1).


Chain Replication specification using actions (part 2).

ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸರಪಳಿ ಪ್ರತಿಕೃತಿ ವಿವರಣೆ (ಭಾಗ 2).


ಒಂದು ಪರಮಾಣು ಓದು/ಬರಹದ ರಿಜಿಸ್ಟರ್.


Behavioral test for atomic read/write registers and the output for the case that NREADERS=NWRITERS= 1.

ಪರಮಾಣು ಓದು/ಬರಹದ ರಿಜಿಸ್ಟರ್‌ಗಳಿಗಾಗಿ ವರ್ತನೆಯ ಪರೀಕ್ಷೆ ಮತ್ತು NREADERS=NWRITERS= 1 ಆಗಿರುವಾಗ ಔಟ್‌ಪುಟ್.


An implementation of a replicated atomic read/write register.

ಪ್ರತಿಕೃತಿಗೊಳಿಸಿದ ಪರಮಾಣು ಓದು/ಬರಹದ ರಿಜಿಸ್ಟರ್‌ನ ಅನುಷ್ಠಾನ.


Distributed consensus code and behavior DFA.

ವಿತರಿಸಿದ ಒಮ್ಮತದ ಕೋಡ್ ಮತ್ತು ವರ್ತನೆಯ DFA.


ಕ್ರ್ಯಾಶ್-ಸಹಿಷ್ಣು ಒಮ್ಮತ ಪ್ರೋಟೋಕಾಲ್.


ಚಿತ್ರ 28.2 ಗಾಗಿ ವರ್ತನೆಯ DFA.


ಸ್ಥಿತಿ ಸ್ಥಳವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು.


A version of the Paxos protocol, Part 1.

ಪಾಕ್ಸೋಸ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ಒಂದು ಆವೃತ್ತಿ, ಭಾಗ 1.


A version of the Paxos protocol, Part 2.

ಪಾಕ್ಸೋಸ್ ಪ್ರೋಟೋಕಾಲ್‌ನ ಒಂದು ಆವೃತ್ತಿ, ಭಾಗ 2.


The program can only take one item at a time.

ಪ್ರೋಗ್ರಾಂ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಒಂದೇ ವಸ್ತುವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.


The person has to cross back and forth several times.

ವ್ಯಕ್ತಿಯು ಹಲವಾರು ಬಾರಿ ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ದಾಟಬೇಕಾಗುತ್ತದೆ.


If left to themselves, the goat would eat the cabbage.

ಮೇಕೆಯನ್ನು ಹಾಗೆಯೇ ಬಿಟ್ಟರೆ, ಅದು ಎಲೆಕೋಸನ್ನು ತಿನ್ನುತ್ತದೆ.


ತೋಳವು ಮೇಕೆಯನ್ನು ತಿನ್ನುತ್ತದೆ.


What crossings does the person need to make?

ವ್ಯಕ್ತಿಯು ಯಾವ ದಾಟುವಿಕೆಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ?


Figure 7.1 specifies the intended behavior of a lock.

ಚಿತ್ರ 7.1 ಲಾಕ್‌ನ ಉದ್ದೇಶಿತ ನಡವಳಿಕೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.


ಲಾಕ್ ಒಂದು ಬೂಲಿಯನ್ ಆಗಿದೆ, ಆರಂಭದಲ್ಲಿ ಸುಳ್ಳು.


The acquire() operation waits until the lock is False.

ಅಕ್ವೈರ್() ಕಾರ್ಯಾಚರಣೆಯು ಲಾಕ್ ಸುಳ್ಳಾಗುವವರೆಗೆ ಕಾಯುತ್ತದೆ.


The release() operation sets the lock back to False.

ರಿಲೀಸ್() ಕಾರ್ಯಾಚರಣೆಯು ಲಾಕ್ ಅನ್ನು ಮತ್ತೆ ಸುಳ್ಳಿಗೆ ಹೊಂದಿಸುತ್ತದೆ.


ಕೋಡ್ ಚಿತ್ರ 5.3 ರಂತೆಯೇ ಇದೆ.


Locks may be used to implement a critical section.

ನಿರ್ಣಾಯಕ ವಿಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.


The code of Figure 7.1 is executable in Harmony.

ಚಿತ್ರ 7.1 ರ ಕೋಡ್ ಹಾರ್ಮೋನಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾಗಿದೆ.


Atomic statements are not intended to replace locks.

ಅಣು ಹೇಳಿಕೆಗಳು ಲಾಕ್‌ಗಳನ್ನು ಬದಲಿಸಲು ಉದ್ದೇಶಿಸಿಲ್ಲ.


Locks are the most prevalent form of synchronization.

ಲಾಕ್‌ಗಳು ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ನ ಅತ್ಯಂತ ಪ್ರಚಲಿತ ರೂಪವಾಗಿದೆ.


You want to protect the data structure with a lock.

ನೀವು ಡೇಟಾ ರಚನೆಯನ್ನು ಲಾಕ್‌ನೊಂದಿಗೆ ರಕ್ಷಿಸಲು ಬಯಸುತ್ತೀರಿ.


ಅದನ್ನು ಡೇಟಾ ರೇಸ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


ಡೇಟಾ ರೇಸ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ.


ನಾವು ಅಣು ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಬಹುದು.


ಈ ವಿಧಾನವನ್ನು ಸ್ಪಿನ್‌ಲಾಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


A more common solution uses an atomic test-and-set instruction.

ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಪರಿಹಾರವೆಂದರೆ ಅಣು ಪರೀಕ್ಷೆ-ಮತ್ತು-ಸೆಟ್ ಸೂಚನೆಯನ್ನು ಬಳಸುವುದು.


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

ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ನಕಲಿಸಲು, ವಿತರಿಸಲು ಮತ್ತು/ಅಥವಾ ಮಾರ್ಪಡಿಸಲು ಅನುಮತಿ ನೀಡಲಾಗಿದೆ.


This document is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0).

ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಕ್ರಿಯೇಟಿವ್ ಕಾಮನ್ಸ್ ಅಟ್ರಿಬ್ಯೂಷನ್-ನಾನ್ ಕಮರ್ಷಿಯಲ್-ಶೇರ್ಅಲೈಕ್ 4.0 ಇಂಟರ್ನ್ಯಾಷನಲ್ (CC BY-NC-SA 4.0) ಅಡಿಯಲ್ಲಿ ಪರವಾನಗಿ ನೀಡಲಾಗಿದೆ.


The document covers topics related to concurrent programming.

ಈ ಡಾಕ್ಯುಮೆಂಟ್ ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


Hello World! is a common introductory program.

ಹಲೋ ವರ್ಲ್ಡ್! ಒಂದು ಸಾಮಾನ್ಯ ಪರಿಚಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ.


Concurrent programming presents several challenges.

ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಹಲವಾರು ಸವಾಲುಗಳನ್ನು ಒಡ್ಡುತ್ತದೆ.


Critical sections are an important concept in concurrent programming.

ನಿರ್ಣಾಯಕ ವಿಭಾಗಗಳು ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ.


Understanding Harmony methods and pointers is crucial.

ಹಾರ್ಮನಿ ವಿಧಾನಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


Specifying a lock is a fundamental step.

ಲಾಕ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು ಒಂದು ಮೂಲಭೂತ ಹಂತವಾಗಿದೆ.


There are different lock implementations.

ವಿವಿಧ ಲಾಕ್ ಅನುಷ್ಠಾನಗಳಿವೆ.


Concurrent data structures require careful design.

ಸಮಕಾಲೀನ ಡೇಟಾ ರಚನೆಗಳು ಎಚ್ಚರಿಕೆಯ ವಿನ್ಯಾಸದ ಅಗತ್ಯವಿದೆ.


Testing is essential for checking behaviors.

ನಡವಳಿಕೆಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಪರೀಕ್ಷೆ ಅತ್ಯಗತ್ಯ.


Debugging concurrent programs can be challenging.

ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು ಸವಾಲಾಗಿರಬಹುದು.


Condition variables are used for conditional waiting.

ಷರತ್ತುಬದ್ಧ ಕಾಯುವಿಕೆಗಾಗಿ ಸ್ಥಿತಿ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


Starvation and deadlock are potential problems.

ಕ್ಷಾಮ ಮತ್ತು ಲಾಕ್‌ಡೌನ್ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳಾಗಿವೆ.


Actors and message passing offer an alternative approach.

ನಟರು ಮತ್ತು ಸಂದೇಶ ರವಾನೆ ಪರ್ಯಾಯ ವಿಧಾನವನ್ನು ನೀಡುತ್ತವೆ.


Barrier synchronization is a useful technique.

ಬ್ಯಾರಿಯರ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಒಂದು ಉಪಯುಕ್ತ ತಂತ್ರವಾಗಿದೆ.


Advanced barrier synchronization provides more control.

ಸುಧಾರಿತ ಬ್ಯಾರಿಯರ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತದೆ.


A concurrent file service is a practical example.

ಸಮಕಾಲೀನ ಫೈಲ್ ಸೇವೆ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಯಾಗಿದೆ.


Interrupts can affect concurrent programs.

ಅಡ್ಡಿಗಳು ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಂಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು.


Non-blocking synchronization is an advanced topic.

ಬ್ಲಾಕ್ ಮಾಡದ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಒಂದು ಸುಧಾರಿತ ವಿಷಯವಾಗಿದೆ.


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

ಯಂತ್ರವು ಹಂಚಿದ ಮೆಮೊರಿ ಸ್ಥಳಗಳಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಪರಮಾಣು ರೀತಿಯಲ್ಲಿ ಹೆಚ್ಚಿಸಲು ಅಥವಾ ಕಡಿಮೆ ಮಾಡಲು ಸೂಚನೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ.


So, to increment a value in memory, the machine must do at least three machine instructions.

ಆದ್ದರಿಂದ, ಮೆಮೊರಿಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸಲು, ಯಂತ್ರವು ಕನಿಷ್ಠ ಮೂರು ಯಂತ್ರ ಸೂಚನೆಗಳನ್ನು ಮಾಡಬೇಕು.


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)


This would fix the issue, but more likely it is the program that must be fixed, not the specification.

ಇದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ, ಆದರೆ ಹೆಚ್ಚಾಗಿ ಇದು ವಿವರಣೆಯಲ್ಲ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸರಿಪಡಿಸಬೇಕು.


Harmony programs can usually be easily translated into Python by hand using minor modifications.

ಹಾರ್ಮನಿ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಣ್ಣ ಮಾರ್ಪಾಡುಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕೈಯಾರೆ ಪೈಥಾನ್‌ಗೆ ಸುಲಭವಾಗಿ ಅನುವಾದಿಸಬಹುದು.


Run Figure 3.4 using Python. Does the assertion fail?

ಪೈಥಾನ್ ಬಳಸಿ ಚಿತ್ರ 3.4 ಅನ್ನು ರನ್ ಮಾಡಿ. ಹೇಳಿಕೆ ವಿಫಲವಾಗುತ್ತದೆಯೇ?


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 ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.


The model checker (called Charm) executes the code in x.hvm and places its output in a file called x.hco.

ಮಾದರಿ ಪರಿಶೀಲಕ (ಚಾರ್ಮ್ ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ) x.hvm ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಔಟ್‌ಪುಟ್ ಅನ್ನು x.hco ಎಂಬ ಫೈಲ್‌ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.


To understand the problem of concurrent computing, it is important to have a basic understanding of machine instructions.

ಸಮಕಾಲೀನ ಕಂಪ್ಯೂಟಿಂಗ್‌ನ ಸಮಸ್ಯೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಯಂತ್ರ ಸೂಚನೆಗಳ ಮೂಲ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರುವುದು ಮುಖ್ಯವಾಗಿದೆ.


Harmony values are recursively defined: They include booleans, integers, strings, sets of Harmony values, lists of Harmony values, dictionaries that map Harmony values to other Harmony values.

ಹಾರ್ಮನಿ ಮೌಲ್ಯಗಳನ್ನು ಮರುಕಳಿಸುವಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ: ಅವು ಬೂಲಿಯನ್‌ಗಳು, ಪೂರ್ಣಾಂಕಗಳು, ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಹಾರ್ಮನಿ ಮೌಲ್ಯಗಳ ಸೆಟ್‌ಗಳು, ಹಾರ್ಮನಿ ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಗಳು, ಹಾರ್ಮನಿ ಮೌಲ್ಯಗಳನ್ನು ಇತರ ಹಾರ್ಮನಿ ಮೌಲ್ಯಗಳಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುವ ನಿಘಂಟುಗಳನ್ನು ಒಳಗೊಂಡಿವೆ.


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.

ಅಕ್ಷರ ಅಥವಾ ಅಂಡರ್‌ಸ್ಕೋರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಮತ್ತು ಅಕ್ಷರಗಳು, ಅಂಕೆಗಳು ಮತ್ತು ಅಂಡರ್‌ಸ್ಕೋರ್‌ಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಚುಕ್ಕೆಗೆ ಮುಂಚಿತವಾಗಿ ಉಲ್ಲೇಖಗಳಿಲ್ಲದೆ ಬರೆಯಬಹುದು.


This code will surely prevent two or more threads from executing in the critical section at the same time.

ಈ ಕೋಡ್ ಖಚಿತವಾಗಿ ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಥ್ರೆಡ್‌ಗಳು ಒಂದೇ ಸಮಯದಲ್ಲಿ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗದಲ್ಲಿ ಕಾರ್ಯಗತವಾಗುವುದನ್ನು ತಡೆಯುತ್ತದೆ.


Mutual exclusion is an example of a safety property, a property that ensures that nothing bad will happen.

ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆಯು ಸುರಕ್ಷತಾ ಗುಣಲಕ್ಷಣದ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ, ಇದು ಕೆಟ್ಟದ್ದೇನೂ ಸಂಭವಿಸದಂತೆ ನೋಡಿಕೊಳ್ಳುವ ಒಂದು ಗುಣಲಕ್ಷಣವಾಗಿದೆ.


We want to ensure that eventually something good will happen.

ಅಂತಿಮವಾಗಿ ಏನಾದರೂ ಒಳ್ಳೆಯದು ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೇವೆ.


If there exists a non-empty set of threads that are trying to enter the critical section and threads in the critical section always leave eventually, then eventually one thread will enter the critical section.

ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಥ್ರೆಡ್‌ಗಳ ಶೂನ್ಯವಲ್ಲದ ಗುಂಪು ಇದ್ದರೆ ಮತ್ತು ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗದಲ್ಲಿನ ಥ್ರೆಡ್‌ಗಳು ಅಂತಿಮವಾಗಿ ಯಾವಾಗಲೂ ಹೊರಟರೆ, ಅಂತಿಮವಾಗಿ ಒಂದು ಥ್ರೆಡ್ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸುತ್ತದೆ.


ನಾವು ಇದನ್ನು ಪ್ರಗತಿ ಎಂದು ಕರೆಯುತ್ತೇವೆ.


In order to detect violations of progress, and other liveness problems in algorithms in general, Harmony requires that every execution must be able to reach a state in which all threads have terminated.

ಪ್ರಗತಿಯ ಉಲ್ಲಂಘನೆಗಳು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಅಲ್ಗಾರಿದಮ್‌ಗಳಲ್ಲಿನ ಇತರ ಲೈವ್‌ನೆಸ್ ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು, ಹಾರ್ಮನಿ ಪ್ರತಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಎಲ್ಲಾ ಥ್ರೆಡ್‌ಗಳು ಮುಕ್ತಾಯಗೊಂಡ ಸ್ಥಿತಿಯನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಾಗಬೇಕೆಂದು ಅಗತ್ಯವಿದೆ.


We will instead model threads in critical sections using the framework in Figure 5.2.

ನಾವು ಬದಲಿಗೆ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗಗಳಲ್ಲಿನ ಥ್ರೆಡ್‌ಗಳನ್ನು ಚಿತ್ರ 5.2 ರಲ್ಲಿನ ಚೌಕಟ್ಟನ್ನು ಬಳಸಿ ಮಾದರಿಯನ್ನು ಮಾಡುತ್ತೇವೆ.


A thread can choose to enter a critical section more than once, but it can also choose to terminate, even without entering the critical section ever.

ಥ್ರೆಡ್ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಆಯ್ಕೆ ಮಾಡಬಹುದು, ಆದರೆ ಅದು ಎಂದಿಗೂ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸದೆಯೇ ಮುಕ್ತಾಯಗೊಳಿಸಲು ಸಹ ಆಯ್ಕೆ ಮಾಡಬಹುದು.


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 and have realized that it could be used to implement a critical section.

ನೀವು ಈಗಾಗಲೇ ಲಾಕ್ ಪರಿಕಲ್ಪನೆಯ ಬಗ್ಗೆ ಕೇಳಿರಬಹುದು ಮತ್ತು ಇದು ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಬಹುದೆಂದು ಅರಿತುಕೊಂಡಿರಬಹುದು.


The idea is that the lock is like a baton that at most one thread can own (or hold) at a time.

ಕಲ್ಪನೆಯೆಂದರೆ ಲಾಕ್ ಒಂದು ಬ್ಯಾಟನ್‌ನಂತಿದೆ, ಇದನ್ನು ಗರಿಷ್ಠ ಒಂದು ಥ್ರೆಡ್ ಒಂದು ಸಮಯದಲ್ಲಿ ಹೊಂದಬಹುದು (ಅಥವಾ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು).


A thread that wants to enter the critical section at a time must obtain the lock first and release it upon exiting the critical section.

ಒಂದು ಸಮಯದಲ್ಲಿ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸುವ ಥ್ರೆಡ್ ಮೊದಲು ಲಾಕ್ ಅನ್ನು ಪಡೆಯಬೇಕು ಮತ್ತು ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗದಿಂದ ನಿರ್ಗಮಿಸಿದ ನಂತರ ಅದನ್ನು ಬಿಡುಗಡೆ ಮಾಡಬೇಕು.


Using a lock is a good thought, but how does one implement one?

ಲಾಕ್ ಬಳಸುವುದು ಒಳ್ಳೆಯ ಆಲೋಚನೆ, ಆದರೆ ಅದನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದು?


Initially the lock is not owned, indicated by lockTaken being False.

ಆರಂಭದಲ್ಲಿ ಲಾಕ್ ಅನ್ನು ಹೊಂದಿಲ್ಲ, ಲಾಕ್ ಟೇಕನ್ ಫಾಲ್ಸ್ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.


To enter the critical section, a thread waits until lockTaken is False and then sets it to True to indicate that the lock has been taken.

ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು, ಥ್ರೆಡ್ ಲಾಕ್ ಟೇಕನ್ ಫಾಲ್ಸ್ ಆಗುವವರೆಗೆ ಕಾಯುತ್ತದೆ ಮತ್ತು ನಂತರ ಲಾಕ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಎಂದು ಸೂಚಿಸಲು ಅದನ್ನು ಟ್ರೂಗೆ ಹೊಂದಿಸುತ್ತದೆ.


The thread then executes the critical section.

ನಂತರ ಥ್ರೆಡ್ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.


Finally, the thread releases the lock by setting lockTaken back to False.

ಅಂತಿಮವಾಗಿ, ಥ್ರೆಡ್ ಲಾಕ್ ಟೇಕನ್ ಅನ್ನು ಮತ್ತೆ ಫಾಲ್ಸ್ ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಲಾಕ್ ಅನ್ನು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ.


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

ಲಾಕ್ ಟೇಕನ್ ವೇರಿಯೇಬಲ್ ಕೌಂಟ್ ವೇರಿಯೇಬಲ್‌ನಂತೆಯೇ ಅದೇ ರೀತಿಯ ರೇಸ್ ಸ್ಥಿತಿಯನ್ನು ಎದುರಿಸುತ್ತದೆ.


Preventing multiple threads from updating the same variable, Figure 5.4 presents a solution based on each thread having a flag indicating that the thread is trying to enter the critical section.

ಒಂದೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನವೀಕರಿಸುವುದರಿಂದ ಬಹು ಥ್ರೆಡ್‌ಗಳನ್ನು ತಡೆಯುವುದು, ಚಿತ್ರ 5.4 ಪ್ರತಿ ಥ್ರೆಡ್ ವಿಮರ್ಶಾತ್ಮಕ ವಿಭಾಗವನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದೆ ಎಂದು ಸೂಚಿಸುವ ಫ್ಲ್ಯಾಗ್ ಹೊಂದಿರುವ ಪರಿಹಾರವನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತದೆ.


ಇಂದು ಸೂರ್ಯ ಪ್ರಕಾಶಮಾನವಾಗಿ ಹೊಳೆಯುತ್ತಿದ್ದಾನೆ.


ದಯವಿಟ್ಟು ನನಗೆ ಉಪ್ಪನ್ನು ನೀಡುತ್ತೀರಾ?


I am going to the market to buy some vegetables.

ನಾನು ತರಕಾರಿಗಳನ್ನು ಖರೀದಿಸಲು ಮಾರುಕಟ್ಟೆಗೆ ಹೋಗುತ್ತಿದ್ದೇನೆ.


The company announced its quarterly earnings report.

ಕಂಪನಿಯು ತನ್ನ ತ್ರೈಮಾಸಿಕ ಗಳಿಕೆಯ ವರದಿಯನ್ನು ಪ್ರಕಟಿಸಿತು.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


She is a talented musician and plays the piano beautifully.

ಅವಳು ಪ್ರತಿಭಾವಂತ ಸಂಗೀತಗಾರಳು ಮತ್ತು ಪಿಯಾನೋವನ್ನು ಸುಂದರವಾಗಿ ನುಡಿಸುತ್ತಾಳೆ.


The government is implementing new policies to boost the economy.

ಆರ್ಥಿಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಸರ್ಕಾರವು ಹೊಸ ನೀತಿಗಳನ್ನು ಜಾರಿಗೆ ತರುತ್ತಿದೆ.


Despite the challenges, they persevered and achieved their goals.

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಅವರು ತಮ್ಮ ಗುರಿಗಳನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸಿದರು.


The research team is conducting experiments in the laboratory.

ಸಂಶೋಧನಾ ತಂಡವು ಪ್ರಯೋಗಾಲಯದಲ್ಲಿ ಪ್ರಯೋಗಗಳನ್ನು ನಡೆಸುತ್ತಿದೆ.


The complex system requires careful analysis and design.

ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗೆ ಎಚ್ಚರಿಕೆಯ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ವಿನ್ಯಾಸದ ಅಗತ್ಯವಿದೆ.


The philosophical implications of artificial intelligence are vast.

ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯ ತಾತ್ವಿಕ ಪರಿಣಾಮಗಳು ವಿಸ್ತಾರವಾಗಿವೆ.


The intricate details of the ancient civilization fascinated the archaeologists.

ಪ್ರಾಚೀನ ನಾಗರಿಕತೆಯ ಸಂಕೀರ್ಣ ವಿವರಗಳು ಪುರಾತತ್ವಶಾಸ್ತ್ರಜ್ಞರನ್ನು ಆಕರ್ಷಿಸಿದವು.


The economic downturn had a significant impact on global markets.

ಆರ್ಥಿಕ ಹಿಂಜರಿತವು ಜಾಗತಿಕ ಮಾರುಕಟ್ಟೆಗಳ ಮೇಲೆ ಗಮನಾರ್ಹ ಪರಿಣಾಮ ಬೀರಿತು.


The company's innovative approach revolutionized the industry.

ಕಂಪನಿಯ ನವೀನ ವಿಧಾನವು ಉದ್ಯಮದಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡಿತು.


The quantum physics theory is still being debated by scientists.

ಕ್ವಾಂಟಮ್ ಭೌತಶಾಸ್ತ್ರದ ಸಿದ್ಧಾಂತವನ್ನು ಇನ್ನೂ ವಿಜ್ಞಾನಿಗಳು ಚರ್ಚಿಸುತ್ತಿದ್ದಾರೆ.


The implications of climate change are far-reaching and require immediate action.

ಹವಾಮಾನ ಬದಲಾವಣೆಯ ಪರಿಣಾಮಗಳು ದೂರಗಾಮಿ ಮತ್ತು ತಕ್ಷಣದ ಕ್ರಮದ ಅಗತ್ಯವಿದೆ.


The intricate interplay of various factors contributed to the success of the project.

ವಿವಿಧ ಅಂಶಗಳ ಸಂಕೀರ್ಣ ಪರಸ್ಪರ ಕ್ರಿಯೆಯು ಯೋಜನೆಯ ಯಶಸ್ಸಿಗೆ ಕಾರಣವಾಯಿತು.


The ethical considerations surrounding genetic engineering are complex and multifaceted.

ಆನುವಂಶಿಕ ಎಂಜಿನಿಯರಿಂಗ್ ಸುತ್ತಲಿನ ನೈತಿಕ ಪರಿಗಣನೆಗಳು ಸಂಕೀರ್ಣ ಮತ್ತು ಬಹುಮುಖಿ.


The artist's profound understanding of human emotions is evident in their work.

ಮಾನವ ಭಾವನೆಗಳ ಕಲಾವಿದನ ಆಳವಾದ ತಿಳುವಳಿಕೆಯು ಅವರ ಕೆಲಸದಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿದೆ.


The government's fiscal policies are designed to stimulate economic growth and reduce unemployment.

ಆರ್ಥಿಕ ಬೆಳವಣಿಗೆಯನ್ನು ಉತ್ತೇಜಿಸಲು ಮತ್ತು ನಿರುದ್ಯೋಗವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸರ್ಕಾರದ ಹಣಕಾಸು ನೀತಿಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


The code was trying to access a shared resource.

ಕೋಡ್ ಹಂಚಿಕೆಯ ಸಂಪನ್ಮೂಲವನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿತ್ತು.


T1 lost the race because T3 removed the node.

ಟಿ 1 ರೇಸ್ ಕಳೆದುಕೊಂಡಿತು ಏಕೆಂದರೆ ಟಿ 3 ನೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಿತು.


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

ಹಾರ್ಮನಿ ನಿಮಗೆ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಮುಂದಕ್ಕೆ ಮತ್ತು ಹಿಂದಕ್ಕೆ ನೋಡಲು ಅನುಮತಿಸುತ್ತದೆ.


The boxes are color-coded: Each method has its own color.

ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಬಣ್ಣ-ಕೋಡ್ ಮಾಡಲಾಗಿದೆ: ಪ್ರತಿಯೊಂದು ವಿಧಾನವು ತನ್ನದೇ ಆದ ಬಣ್ಣವನ್ನು ಹೊಂದಿದೆ.


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

ಟಿ 1 ಮೊದಲು ಪುಟ್(?ಕ್ಯೂ, 1) ಅನ್ನು ಕರೆಯುತ್ತದೆ ಮತ್ತು ನಂತರ ಲಾಕ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲಾದ ಹೊಸ ನೋಡ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ.


You can see that variable nq is initialized to ?q.

ವೇರಿಯೇಬಲ್ ಎನ್‌ಕ್ಯೂ ಅನ್ನು ?ಕ್ಯೂ ಗೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ನೋಡಬಹುದು.


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

ಟಿ 1 ನಂತರ ವೈಲ್ ಲೂಪ್‌ಗೆ ಪ್ರವೇಶಿಸುತ್ತದೆ ಮತ್ತು ಎನ್‌ಕ್ಯೂ→ಲಾಕ್ ಅನ್ನು ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.


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

ಸಮಸ್ಯೆ ಇರುವುದು ಇಲ್ಲಿದೆ—ಟಿ 1 ಅದೇ ನೋಡ್‌ನಲ್ಲಿ ಲಾಕ್ ಅನ್ನು ಪಡೆಯಲು ಸಿದ್ಧವಾಗಿದೆ.


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

ಡೇಟಾ ರಚನೆಯನ್ನು ಬದಲಾಯಿಸದೆ ಕೋಡ್ ಅನ್ನು ಸರಿಪಡಿಸಲು, ನಾವು ಹ್ಯಾಂಡ್-ಓವರ್-ಹ್ಯಾಂಡ್ ಲಾಕಿಂಗ್ ಅನ್ನು ಬಳಸಬಹುದು.


Figure 11.4 shows an implementation that uses hand-over-hand locking both for put() and forget().

ಚಿತ್ರ 11.4 ಪುಟ್() ಮತ್ತು ಫರ್ಗೆಟ್() ಎರಡಕ್ಕೂ ಹ್ಯಾಂಡ್-ಓವರ್-ಹ್ಯಾಂಡ್ ಲಾಕಿಂಗ್ ಅನ್ನು ಬಳಸುವ ಅನುಷ್ಠಾನವನ್ನು ತೋರಿಸುತ್ತದೆ.


Critical sections enable multiple threads to easily share data structures.

ನಿರ್ಣಾಯಕ ವಿಭಾಗಗಳು ಅನೇಕ ಥ್ರೆಡ್‌ಗಳು ಡೇಟಾ ರಚನೆಗಳನ್ನು ಸುಲಭವಾಗಿ ಹಂಚಿಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.


A critical section only allows one thread to execute the code at a time.

ನಿರ್ಣಾಯಕ ವಿಭಾಗವು ಒಂದು ಸಮಯದಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕೇವಲ ಒಂದು ಥ್ರೆಡ್ ಅನ್ನು ಮಾತ್ರ ಅನುಮತಿಸುತ್ತದೆ.


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.

ಕೆಲವೊಮ್ಮೆ ನಿರ್ಣಾಯಕ ವಿಭಾಗವು ಆಕ್ರಮಿಸಲ್ಪಡದಿದ್ದರೂ ಹೆಚ್ಚುವರಿ ಪರಿಸ್ಥಿತಿಗಳಿಗಾಗಿ ಕಾಯುವುದು ಥ್ರೆಡ್‌ಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.


We would like to find a solution to conditional waiting so that a thread blocks until the condition holds.

ಒಂದು ಥ್ರೆಡ್ ಸ್ಥಿತಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವವರೆಗೆ ನಿರ್ಬಂಧಿಸುವಂತೆ ಷರತ್ತುಬದ್ಧ ಕಾಯುವಿಕೆಗೆ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾವು ಬಯಸುತ್ತೇವೆ.


Locks are useful when accessing a shared data structure.

ಹಂಚಿದ ಡೇಟಾ ರಚನೆಯನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ಲಾಕ್‌ಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ.


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.

ರೀಡರ್/ರೈಟರ್ ಲಾಕ್ ಎಂದರೆ ಎರಡು ಪೂರ್ಣಾಂಕ ಕೌಂಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ವಸ್ತುವಾಗಿದೆ.


The network protocol ensures reliable message delivery between threads.

ನೆಟ್‌ವರ್ಕ್ ಪ್ರೋಟೋಕಾಲ್ ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ವಿಶ್ವಾಸಾರ್ಹ ಸಂದೇಶ ವಿತರಣೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.


Alice sends messages m1 to mn in order, and Bob receives them.

ಆಲಿಸ್ ಸಂದೇಶಗಳನ್ನು m1 ನಿಂದ mn ವರೆಗೆ ಕ್ರಮವಾಗಿ ಕಳುಹಿಸುತ್ತಾಳೆ, ಮತ್ತು ಬಾಬ್ ಅವುಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾನೆ.


The Alternating Bit Protocol is suitable for our purposes.

ಆಲ್ಟರ್ನೇಟಿಂಗ್ ಬಿಟ್ ಪ್ರೋಟೋಕಾಲ್ ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗೆ ಸೂಕ್ತವಾಗಿದೆ.


Alice and Bob each maintain a sequence number.

ಆಲಿಸ್ ಮತ್ತು ಬಾಬ್ ಪ್ರತಿಯೊಬ್ಬರೂ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಾರೆ.


When Bob receives a message, he returns an acknowledgment.

ಬಾಬ್ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಅವನು ಸ್ವೀಕೃತಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತಾನೆ.


ಇದನ್ನು ಮರುಪ್ರಸರಣ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Bob waits until he receives a message matching his sequence number.

ಬಾಬ್ ತನ್ನ ಅನುಕ್ರಮ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುವವರೆಗೆ ಕಾಯುತ್ತಾನೆ.


ಒಂದು-ಬಿಟ್ ಅನುಕ್ರಮ ಸಂಖ್ಯೆ ಸಾಕಾಗುತ್ತದೆ.


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.

ಸ್ವೀಕೃತಿ ಸ್ವೀಕರಿಸುವವರೆಗೆ ಅಪ್‌ಸೆಂಡ್ ವಿಧಾನವು ಮರುಪ್ರಸಾರ ಮಾಡುತ್ತದೆ.


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.

ಬಹು ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಪರಿಹಾರವನ್ನು ಸಾಮಾನ್ಯೀಕರಿಸಿ.


TCP ಸ್ಲೈಡಿಂಗ್ ವಿಂಡೋ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


ಸ್ಲೈಡಿಂಗ್ ವಿಂಡೋ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ.


Leader election is the problem of electing a unique leader.

ಲೀಡರ್ ಚುನಾವಣೆಯು ಅನನ್ಯ ನಾಯಕನನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಸಮಸ್ಯೆಯಾಗಿದೆ.


ಪ್ರತಿಯೊಂದು ಪ್ರೊಸೆಸರ್ ಅನನ್ಯ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೊಂದಿದೆ.


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.

ಉಳಿದ ಮೂರು ಷರತ್ತುಗಳನ್ನು ತಪ್ಪಿಸುವ ಕೆಳಗಿನ ತಂತ್ರಗಳನ್ನು ಹ್ಯಾವೆಂಡರ್ ಪ್ರಸ್ತಾಪಿಸಿದರು.


No Hold and Wait: a thread must request all resources it is going to need at the same time.

ಹೋಲ್ಡ್ ಮತ್ತು ವೇಟ್ ಇಲ್ಲ: ಥ್ರೆಡ್ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ವಿನಂತಿಸಬೇಕು.


Preemption: if a thread is denied a request for a resource, it must release all resources that it has already acquired and start over.

ಪೂರ್ವಭಾವಿ ಹಕ್ಕು: ಥ್ರೆಡ್‌ಗೆ ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ ವಿನಂತಿಯನ್ನು ನಿರಾಕರಿಸಿದರೆ, ಅದು ಈಗಾಗಲೇ ಪಡೆದುಕೊಂಡಿರುವ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಬೇಕು ಮತ್ತು ಮತ್ತೆ ಪ್ರಾರಂಭಿಸಬೇಕು.


The file service implementation will use a collection of worker threads.

ಫೈಲ್ ಸೇವಾ ಅನುಷ್ಠಾನವು ಕೆಲಸಗಾರ ಥ್ರೆಡ್‌ಗಳ ಸಂಗ್ರಹವನ್ನು ಬಳಸುತ್ತದೆ.


Clients of the file service implementation use blocking synchronized queues.

ಫೈಲ್ ಸೇವಾ ಅನುಷ್ಠಾನದ ಗ್ರಾಹಕರು ಬ್ಲಾಕಿಂಗ್ ಸಿಂಕ್ರೊನೈಸ್ಡ್ ಸರತಿ ಸಾಲುಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.


The example will also illustrate modular model checking.

ಉದಾಹರಣೆಯು ಮಾಡ್ಯುಲರ್ ಮಾದರಿ ಪರಿಶೀಲನೆಯನ್ನು ಸಹ ವಿವರಿಸುತ್ತದೆ.


We will focus here on a low-level notion of a file.

ನಾವು ಇಲ್ಲಿ ಫೈಲ್‌ನ ಕಡಿಮೆ-ಮಟ್ಟದ ಪರಿಕಲ್ಪನೆಯ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ.


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

ನಮ್ಮ ಅಮೂರ್ತತೆಯಲ್ಲಿ, ಪ್ರತಿ ಬ್ಲಾಕ್ ಒಂದು ಅನಿಯಂತ್ರಿತ ಹಾರ್ಮನಿ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.


A more complete file system would keep track of various additional information.

ಹೆಚ್ಚು ಸಂಪೂರ್ಣವಾದ ಫೈಲ್ ಸಿಸ್ಟಮ್ ವಿವಿಧ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ.


Such abstractions can be modularly implemented on top.

ಅಂತಹ ಅಮೂರ್ತತೆಗಳನ್ನು ಮಾಡ್ಯುಲರ್ ರೀತಿಯಲ್ಲಿ ಮೇಲೆ ಅಳವಡಿಸಬಹುದು.


Figure 19.1 shows the file system interface.

ಚಿತ್ರ 19.1 ಫೈಲ್ ಸಿಸ್ಟಮ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ.


Just like in Unix-like file systems, you have to specify the number of files.

Unix-ನಂತಹ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿರುವಂತೆ, ನೀವು ಫೈಲ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು.


File(n) returns a handle that must be passed to file operations.

File(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.

read(fs,ino,offset) ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಫ್‌ಸೆಟ್‌ನಲ್ಲಿ fileino ಬ್ಲಾಕ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


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.

ಅಗತ್ಯವಿದ್ದರೆ, ಫೈಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಸೇರಿಸಲು ಬೆಳೆಸಲಾಗುತ್ತದೆ.


Figure 19.2 shows how the file system may be tested.

ಚಿತ್ರ 19.2 ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೇಗೆ ಪರೀಕ್ಷಿಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.


We can do this for both the specification and implementation.

ನಾವು ಇದನ್ನು ವಿವರಣೆ ಮತ್ತು ಅನುಷ್ಠಾನ ಎರಡಕ್ಕೂ ಮಾಡಬಹುದು.


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

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು, ನಾವು ಡಿಸ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.


Each block is identified by its offset or block number.

ಪ್ರತಿ ಬ್ಲಾಕ್ ಅನ್ನು ಅದರ ಆಫ್‌ಸೆಟ್ ಅಥವಾ ಬ್ಲಾಕ್ ಸಂಖ್ಯೆಯಿಂದ ಗುರುತಿಸಲಾಗುತ್ತದೆ.


ಕಾರ್ಯಾಚರಣೆಗಳು ಪರಮಾಣು ಅಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.


For the implementation, we will use a simplified Unix file system.

ಅನುಷ್ಠಾನಕ್ಕಾಗಿ, ನಾವು ಸರಳೀಕೃತ Unix ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಸಮರ್ಥವಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


Please provide your identification details.

ದಯವಿಟ್ಟು ನಿಮ್ಮ ಗುರುತಿನ ವಿವರಗಳನ್ನು ಒದಗಿಸಿ.


The company announced a new product launch.

ಕಂಪನಿಯು ಹೊಸ ಉತ್ಪನ್ನ ಬಿಡುಗಡೆಯನ್ನು ಘೋಷಿಸಿತು.


He is a highly skilled software engineer.

ಅವರು ಅತ್ಯಂತ ನುರಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರ್ ಆಗಿದ್ದಾರೆ.


The weather forecast predicts heavy rainfall.

ಹವಾಮಾನ ಮುನ್ಸೂಚನೆಯು ಭಾರೀ ಮಳೆಯಾಗುವ ಸಾಧ್ಯತೆಯಿದೆ ಎಂದು ತಿಳಿಸುತ್ತದೆ.


Could you please repeat that information?

ದಯವಿಟ್ಟು ಆ ಮಾಹಿತಿಯನ್ನು ಪುನರಾವರ್ತಿಸಬಹುದೇ?


The project requires careful planning and execution.

ಯೋಜನೆಗೆ ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಮತ್ತು ಅನುಷ್ಠಾನದ ಅಗತ್ಯವಿದೆ.


She enjoys reading novels in her free time.

ಅವಳು ತನ್ನ ಬಿಡುವಿನ ವೇಳೆಯಲ್ಲಿ ಕಾದಂಬರಿಗಳನ್ನು ಓದುವುದನ್ನು ಆನಂದಿಸುತ್ತಾಳೆ.


The economic situation is improving gradually.

ಆರ್ಥಿಕ ಪರಿಸ್ಥಿತಿ ಕ್ರಮೇಣ ಸುಧಾರಿಸುತ್ತಿದೆ.


The complex system requires specialized knowledge.

ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗೆ ವಿಶೇಷ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ.


The government implemented new regulations.

ಸರ್ಕಾರವು ಹೊಸ ನಿಯಮಗಳನ್ನು ಜಾರಿಗೆ ತಂದಿದೆ.


He is working on a challenging research paper.

ಅವರು ಒಂದು ಸವಾಲಿನ ಸಂಶೋಧನಾ ಪ್ರಬಂಧದ ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ.


ಸಮ್ಮೇಳನವು ಮುಂದಿನ ತಿಂಗಳು ನಡೆಯಲಿದೆ.


The data analysis revealed significant insights.

ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆಯು ಮಹತ್ವದ ಒಳನೋಟಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಿತು.


She is a talented musician and composer.

ಅವಳು ಪ್ರತಿಭಾವಂತ ಸಂಗೀತಗಾರ ಮತ್ತು ಸಂಯೋಜಕಿಯಾಗಿದ್ದಾಳೆ.


The company's profits increased substantially.

ಕಂಪನಿಯ ಲಾಭವು ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಾಗಿದೆ.


The intricate design required careful attention to detail.

சிக்கலான ವಿನ್ಯಾಸಕ್ಕೆ ವಿವರಗಳಿಗೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಗಮನಹರಿಸುವ ಅಗತ್ಯವಿತ್ತು.


The negotiations were successful and concluded with an agreement.

переговориಗಳು ಯಶಸ್ವಿಯಾದವು ಮತ್ತು ಒಪ್ಪಂದದೊಂದಿಗೆ ಮುಕ್ತಾಯಗೊಂಡವು.


Despite the challenges, they persevered and achieved their goals.

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಅವರು ತಮ್ಮ ಗುರಿಗಳನ್ನು ಸಾಧಿಸಲು ಪ್ರಯತ್ನಿಸಿದರು.


The implications of the new policy are far-reaching and complex.

ಹೊಸ ನೀತಿಯ ಪರಿಣಾಮಗಳು ದೂರಗಾಮಿ ಮತ್ತು ಸಂಕೀರ್ಣವಾಗಿವೆ.


ಇಂದು ಸೂರ್ಯ ಪ್ರಕಾಶಮಾನವಾಗಿ ಹೊಳೆಯುತ್ತಿದ್ದಾನೆ.


ದಯವಿಟ್ಟು ಬಾಗಿಲು ಮುಚ್ಚಿ.


I am going to the market to buy some vegetables.

ನಾನು ತರಕಾರಿಗಳನ್ನು ಖರೀದಿಸಲು ಮಾರುಕಟ್ಟೆಗೆ ಹೋಗುತ್ತಿದ್ದೇನೆ.


The company announced its quarterly profits.

ಕಂಪನಿಯು ತನ್ನ ತ್ರೈಮಾಸಿಕ ಲಾಭವನ್ನು ಘೋಷಿಸಿತು.


Could you please help me with this problem?

ದಯವಿಟ್ಟು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನೀವು ನನಗೆ ಸಹಾಯ ಮಾಡಬಹುದೇ?


The research paper explores the impact of climate change.

ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ಹವಾಮಾನ ಬದಲಾವಣೆಯ ಪರಿಣಾಮವನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ.


ಅವರು ತುಂಬಾ ಪ್ರತಿಭಾವಂತ ಸಂಗೀತಗಾರ.


The meeting will be held tomorrow at 10 AM.

ನಾಳೆ ಬೆಳಿಗ್ಗೆ 10 ಗಂಟೆಗೆ ಸಭೆ ನಡೆಯಲಿದೆ.


She enjoys reading novels in her free time.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


The government implemented new policies.

ಸರ್ಕಾರವು ಹೊಸ ನೀತಿಗಳನ್ನು ಜಾರಿಗೆ ತಂದಿದೆ.


The complex system requires careful analysis.

ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗೆ ಎಚ್ಚರಿಕೆಯ ವಿಶ್ಲೇಷಣೆ ಅಗತ್ಯವಿದೆ.


He is known for his honesty and integrity.

ಅವರು ತಮ್ಮ ಪ್ರಾಮಾಣಿಕತೆ ಮತ್ತು ಸಮಗ್ರತೆಗೆ ಹೆಸರುವಾಸಿಯಾಗಿದ್ದಾರೆ.


ಯೋಜನೆಯನ್ನು ನಿಗದಿತ ಸಮಯದಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಲಾಯಿತು.


ಅವಳು ಅದ್ಭುತ ವಿದ್ಯಾರ್ಥಿನಿ.


The data analysis revealed interesting insights.

ದತ್ತಾಂಶ ವಿಶ್ಲೇಷಣೆಯು ಆಸಕ್ತಿದಾಯಕ ಒಳನೋಟಗಳನ್ನು ಬಹಿರಂಗಪಡಿಸಿತು.


ಆರ್ಥಿಕ ಮುನ್ಸೂಚನೆಯು ಬೆಳವಣಿಗೆಯನ್ನು ಊಹಿಸುತ್ತದೆ.


The software update includes new features.

ಸಾಫ್ಟ್‌ವೇರ್ ನವೀಕರಣವು ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


The artist's work is displayed in the gallery.

ಕಲಾವಿದನ ಕೆಲಸವನ್ನು ಗ್ಯಾಲರಿಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗಿದೆ.


The company is committed to sustainability.

ಕಂಪನಿಯು ಸುಸ್ಥಿರತೆಗೆ ಬದ್ಧವಾಗಿದೆ.


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.

ಇದಕ್ಕಾಗಿ, ಇದು ವಿತರಿಸಲಾದ ವಿನಂತಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಕೌಂಟರ್ ವಿತರಿಸಲ್ಪಟ್ಟಿದೆ.


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 Harmony compiler analyzes the code for potential issues.

ಹಾರ್ಮನಿ ಕಂಪೈಲರ್ ಕೋಡ್‌ನಲ್ಲಿನ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತದೆ.


The program checks for safety violations during model checking.

ಮಾದರಿ ಪರಿಶೀಲನೆಯ ಸಮಯದಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ಸುರಕ್ಷತಾ ಉಲ್ಲಂಘನೆಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.


The compiler generates bytecode from the Harmony source code.

ಕಂಪೈಲರ್ ಹಾರ್ಮನಿ ಮೂಲ ಕೋಡ್‌ನಿಂದ ಬೈಟ್‌ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.


The test program starts a thread for each operation.

ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಗಾಗಿ ಪರೀಕ್ಷಾ ಕಾರ್ಯಕ್ರಮವು ಒಂದು ಥ್ರೆಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.


The Harmony file extensions include .hny and .hvm.

ಹಾರ್ಮನಿ ಫೈಲ್ ವಿಸ್ತರಣೆಗಳು .hny ಮತ್ತು .hvm ಅನ್ನು ಒಳಗೊಂಡಿವೆ.


The model checker generates a graph of all reachable states.

ಮಾದರಿ ಪರಿಶೀಲಕವು ಎಲ್ಲಾ ತಲುಪಬಹುದಾದ ಸ್ಥಿತಿಗಳ ಗ್ರಾಫ್ ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.


The program uses a sequential queue specification.

ಪ್ರೋಗ್ರಾಂ ಅನುಕ್ರಮ ಸರತಿ ವಿಶೇಷಣವನ್ನು ಬಳಸುತ್ತದೆ.


The test program maintains a global time variable.

ಪರೀಕ್ಷಾ ಕಾರ್ಯಕ್ರಮವು ಜಾಗತಿಕ ಸಮಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


The Harmony compiler also generates .tla files.

ಹಾರ್ಮನಿ ಕಂಪೈಲರ್ .tla ಫೈಲ್‌ಗಳನ್ನು ಸಹ ಉತ್ಪಾದಿಸುತ್ತದೆ.


The options can change the behavior of the compiler.

ಆಯ್ಕೆಗಳು ಕಂಪೈಲರ್‌ನ ನಡವಳಿಕೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು.


Gary L. Peterson came up with a solution to the mutual exclusion problem.

ಗ್ಯಾರಿ ಎಲ್. ಪೀಟರ್ಸನ್ ಪರಸ್ಪರ ಹೊರಗಿಡುವ ಸಮಸ್ಯೆಗೆ ಒಂದು ಪರಿಹಾರವನ್ನು ಕಂಡುಕೊಂಡರು.


The HVM starts in an initial state with one thread.

HVM ಒಂದು ಥ್ರೆಡ್‌ನೊಂದಿಗೆ ಆರಂಭಿಕ ಸ್ಥಿತಿಯಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.


ಹಾರ್ಮನಿಯಲ್ಲಿನ ಕ್ರಮಗಳು ಪರಮಾಣುಗಳಾಗಿವೆ.


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

ಒಂದು ಟ್ರೇಸ್ ಎಂದರೆ ಆರಂಭಿಕ ಸ್ಥಿತಿಯಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಹಂತಗಳ ಅನುಕ್ರಮವಾಗಿದೆ.


We want to show that exclusivity is an invariant.

ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆಯು ಒಂದು ಸ್ಥಿರಾಂಕವಾಗಿದೆ ಎಂದು ನಾವು ತೋರಿಸಲು ಬಯಸುತ್ತೇವೆ.


An inductive invariant implies exclusivity.

ಒಂದು ಇಂಡಕ್ಟಿವ್ ಸ್ಥಿರಾಂಕವು ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.


The Split Binary Semaphore (SBS) is a general technique.

ಸ್ಪ್ಲಿಟ್ ಬೈನರಿ ಸೆಮಾಫೋರ್ (SBS) ಒಂದು ಸಾಮಾನ್ಯ ತಂತ್ರವಾಗಿದೆ.


SBS n+1 ಬೈನರಿ ಸೆಮಾಫೋರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


A binary semaphore is a generalization of a lock.

ಬೈನರಿ ಸೆಮಾಫೋರ್ ಒಂದು ಲಾಕ್‌ನ ಸಾಮಾನ್ಯೀಕರಣವಾಗಿದೆ.


The main gate is implemented by a binary semaphore.

ಮುಖ್ಯ ದ್ವಾರವನ್ನು ಬೈನರಿ ಸೆಮಾಫೋರ್‌ನಿಂದ ಅಳವಡಿಸಲಾಗಿದೆ.


ಈ ಸಂದರ್ಭದಲ್ಲಿ, !?a(b) a(b) ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ.


This can be used to implement generators.

ಇದನ್ನು ಜನರೇಟರ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಬಹುದು.


For example, the following Harmony program, perhaps surprisingly, does not run into failing assertions:

ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಹಾರ್ಮನಿ ಪ್ರೋಗ್ರಾಂ, ಆಶ್ಚರ್ಯಕರವಾಗಿ, ವೈಫಲ್ಯದ ಹೇಳಿಕೆಗಳಿಗೆ ಬರುವುದಿಲ್ಲ:


Internally, Harmony uses the address of a method variable and sometimes you see them on the stack during a computation.

ಆಂತರಿಕವಾಗಿ, ಹಾರ್ಮನಿ ವಿಧಾನದ ವೇರಿಯೇಬಲ್‌ನ ವಿಳಾಸವನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ನೀವು ಅವುಗಳನ್ನು ಲೆಕ್ಕಾಚಾರದ ಸಮಯದಲ್ಲಿ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ನೋಡುತ್ತೀರಿ.


If k is a method variable, then its address is output as ?@k.

k ಒಂದು ವಿಧಾನದ ವೇರಿಯೇಬಲ್ ಆಗಿದ್ದರೆ, ಅದರ ವಿಳಾಸವನ್ನು ?@k ಎಂದು ಔಟ್‌ಪುಟ್ ಮಾಡಲಾಗುತ್ತದೆ.


However, there is no such thing as the address of a local variable.

ಆದಾಗ್ಯೂ, ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್‌ನ ವಿಳಾಸ ಎಂಬುದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.


ಕೆಳಗಿನ ಎರಡು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಪರಿಗಣಿಸಿ:


In the program on the left, x is a shared variable, and ?x is the location of variable x.

ಎಡಭಾಗದಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, x ಒಂದು ಹಂಚಿಕೆಯ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ, ಮತ್ತು ?x ವೇರಿಯೇಬಲ್ x ನ ಸ್ಥಳವಾಗಿದೆ.


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

ಬಲಭಾಗದಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, x ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್ ಆಗಿದೆ.


?x evaluates x and then takes its address, so in this case ?x equals ?1.

?x, x ಅನ್ನು ಮೌಲ್ಯೀಕರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದರ ವಿಳಾಸವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ?x, ?1 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ.


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

C ಯಂತೆ, ಹಾರ್ಮನಿ (!p).v ಅಭಿವ್ಯಕ್ತಿಗಾಗಿ ಸಂಕ್ಷಿಪ್ತ ರೂಪ p→v ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.


A context value (a.k.a. continuation) captures the state of a thread.

ಸಂದರ್ಭ ಮೌಲ್ಯ (a.k.a. ಮುಂದುವರಿಕೆ) ಥ್ರೆಡ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಸೆರೆಹಿಡಿಯುತ್ತದೆ.


The save expression, when invoked, returns a tuple (e, c) where c is the context value of the thread right after the save instruction finished.

ಸೇವ್ ಅಭಿವ್ಯಕ್ತಿ, ಕರೆದಾಗ, ಟ್ಯೂಪಲ್ (e, c) ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಲ್ಲಿ c ಎಂದರೆ ಸೇವ್ ಸೂಚನೆಯು ಮುಗಿದ ನಂತರ ಥ್ರೆಡ್‌ನ ಸಂದರ್ಭ ಮೌಲ್ಯ.


Using go c the context can be turned into a new thread that, instead, returns r from the save expression.

ಗೋ ಸಿ ಬಳಸುವುದರಿಂದ ಸಂದರ್ಭವನ್ನು ಹೊಸ ಥ್ರೆಡ್ ಆಗಿ ಪರಿವರ್ತಿಸಬಹುದು, ಅದು ಬದಲಿಗೆ ಸೇವ್ ಅಭಿವ್ಯಕ್ತಿಯಿಂದ r ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.


See Figure A.1 for an example of how this could be used to fork a thread into two threads.

ಥ್ರೆಡ್ ಅನ್ನು ಎರಡು ಥ್ರೆಡ್‌ಗಳಾಗಿ ಫೋರ್ಕ್ ಮಾಡಲು ಇದನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದಕ್ಕೆ ಉದಾಹರಣೆಗಾಗಿ ಚಿತ್ರ A.1 ನೋಡಿ.


The stop expression stores the context of the thread right after the expression in !p (i.e., p must be an address value) and terminates the thread.

ಸ್ಟಾಪ್ ಅಭಿವ್ಯಕ್ತಿ !p ನಲ್ಲಿನ ಅಭಿವ್ಯಕ್ತಿಯ ನಂತರ ಥ್ರೆಡ್‌ನ ಸಂದರ್ಭವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ಅಂದರೆ, p ಒಂದು ವಿಳಾಸ ಮೌಲ್ಯವಾಗಿರಬೇಕು) ಮತ್ತು ಥ್ರೆಡ್ ಅನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ.


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

ಥ್ರೆಡ್ ಅನ್ನು ಸ್ಟಾಪ್ ನನ್ ಅಥವಾ ಸ್ಟಾಪ್() ಅನ್ನು ಬಳಸಿಕೊಂಡು ಶಾಶ್ವತವಾಗಿ ಅಮಾನತುಗೊಳಿಸಬಹುದು.


Harmony currently supports the following statements:

ಹಾರ್ಮನಿ ಪ್ರಸ್ತುತ ಕೆಳಗಿನ ಹೇಳಿಕೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ:


Single expression evaluation Any expression by itself can be used as a statement.

ಏಕ ಅಭಿವ್ಯಕ್ತಿ ಮೌಲ್ಯಮಾಪನ ಯಾವುದೇ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಸ್ವತಃ ಒಂದು ಹೇಳಿಕೆಯಾಗಿ ಬಳಸಬಹುದು.


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

x = 3 ಹೇಳಿಕೆಯು ವೇರಿಯೇಬಲ್ x ಗೆ 3 ಅನ್ನು ನಿಯೋಜಿಸುವ ಮೂಲಕ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.


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 is implemented using Hoare monitors in the example.

ಉದಾಹರಣೆಯಲ್ಲಿ ಹೋರೆ ಮಾನಿಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಒಂದು ಸೀಮಿತ ಬಫರ್ ಅನ್ನು ಅಳವಡಿಸಲಾಗಿದೆ.


The `put` method adds an item to the bounded buffer.

`put` ವಿಧಾನವು ಸೀಮಿತ ಬಫರ್‌ಗೆ ಒಂದು ಐಟಂ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.


The `get` method retrieves an item from the bounded buffer.

`get` ವಿಧಾನವು ಸೀಮಿತ ಬಫರ್‌ನಿಂದ ಒಂದು ಐಟಂ ಅನ್ನು ಹಿಂಪಡೆಯುತ್ತದೆ.


If the buffer is full, the `put` method waits.

ಬಫರ್ ತುಂಬಿದ್ದರೆ, `put` ವಿಧಾನವು ಕಾಯುತ್ತದೆ.


If the buffer is empty, the `get` method waits.

ಬಫರ್ ಖಾಲಿಯಾಗಿದ್ದರೆ, `get` ವಿಧಾನವು ಕಾಯುತ್ತದೆ.


The example demonstrates the producer-consumer problem.

ಉದಾಹರಣೆಯು ಉತ್ಪಾದಕ-ಗ್ರಾಹಕ ಸಮಸ್ಯೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.


Hoare monitors use condition variables for synchronization.

ಹೋರೆ ಮಾನಿಟರ್‌ಗಳು ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ಗಾಗಿ ಸ್ಥಿತಿ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸುತ್ತವೆ.


The code uses mutexes to protect critical sections.

ಕೋಡ್ ನಿರ್ಣಾಯಕ ವಿಭಾಗಗಳನ್ನು ರಕ್ಷಿಸಲು ಮ್ಯೂಟೆಕ್ಸ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


Understanding concurrency is crucial for writing efficient software.

ಸಮರ್ಥ ಸಾಫ್ಟ್‌ವೇರ್ ಬರೆಯಲು ಸಮಕಾಲೀನತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


The example shows how to avoid data races.

ಉದಾಹರಣೆಯು ಡೇಟಾ ರೇಸ್‌ಗಳನ್ನು ಹೇಗೆ ತಪ್ಪಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.


The `signal` method wakes up a waiting thread.

`signal` ವಿಧಾನವು ಕಾಯುತ್ತಿರುವ ಥ್ರೆಡ್ ಅನ್ನು ಎಚ್ಚರಗೊಳಿಸುತ್ತದೆ.


The `wait` method blocks a thread until a condition is met.

`wait` ವಿಧಾನವು ಒಂದು ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸುವವರೆಗೆ ಥ್ರೆಡ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.


This code is an example of concurrent programming.

ಈ ಕೋಡ್ ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.


The bounded buffer helps manage shared resources.

ಸೀಮಿತ ಬಫರ್ ಹಂಚಿದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


The code uses semaphores for synchronization.

ಕೋಡ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ಗಾಗಿ ಸೆಮಾಫೋರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


Concurrency can improve the performance of applications.

ಸಮಕಾಲೀನತೆಯು ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.


The example illustrates the use of monitors.

ಉದಾಹರಣೆಯು ಮಾನಿಟರ್‌ಗಳ ಬಳಕೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ.


Careful synchronization is essential to avoid deadlocks.

ಡೆಡ್‌ಲಾಕ್‌ಗಳನ್ನು ತಪ್ಪಿಸಲು ಎಚ್ಚರಿಕೆಯ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅತ್ಯಗತ್ಯ.