The document discusses various concepts related to database transactions and concurrency control including deadlock, deadlock prevention schemes, isolation levels, and locking protocols. It defines deadlock as when multiple processes wait indefinitely for resources held by each other. It describes the wait-die and wound-wait schemes for deadlock prevention using timestamp ordering. It also discusses intent locks, two phase locking protocol, and the growing and shrinking phases of a transaction.
Set operations allow combining results from multiple SELECT statements. There are four main types:
Union combines results and eliminates duplicates. Intersect returns only common records. Union All and Intersect All also show duplicate rows. Syntax involves a SELECT query followed by a set operator and another SELECT query.
Concurrency Control in Distributed Database.Meghaj Mallick
The document discusses various techniques for concurrency control in distributed databases, including locking-based protocols and timestamp-based protocols. Locking-based protocols use exclusive and shared locks to control concurrent access to data items. They can be implemented using a single or distributed lock manager. Timestamp-based protocols assign each transaction a unique timestamp to determine serialization order and manage concurrent execution.
Distributed database management systems (DDBMS) allow data to be spread across multiple computer sites connected by a network. A DDBMS provides location transparency so users can access data without knowing its physical location. It also coordinates transactions that involve data stored at multiple sites. DDBMS architectures include transaction managers, data managers, and transaction coordinators to process transactions and subtransactions across distributed data.
This document discusses deadlock prevention by invalidating one of the four conditions necessary for deadlock: mutual exclusion, hold and wait, no preemption, and circular wait. It describes strategies to prevent each condition, such as not requiring mutual exclusion for sharable resources, requesting all resources before execution or only when a process has none to prevent hold and wait, allowing preemption of held resources to prevent no preemption, and imposing a total ordering of resource requests to prevent circular wait. These techniques aim to ensure deadlock is excluded from the beginning.
This document discusses concurrency control algorithms for distributed database systems. It describes distributed two-phase locking (2PL), wound-wait, basic timestamp ordering, and distributed optimistic concurrency control algorithms. For distributed 2PL, transactions lock data items in a growing phase and release locks in a shrinking phase. Wound-wait prevents deadlocks by aborting younger transactions that wait on older ones. Basic timestamp ordering orders transactions based on their timestamps to ensure serializability. The distributed optimistic approach allows transactions to read and write freely until commit, when certification checks for conflicts. Maintaining consistency across distributed copies is important for concurrency control algorithms.
In computer science, divide and conquer is an algorithm design paradigm based on multi-branched recursion. A divide-and-conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type until these become simple enough to be solved directly.
Set operations allow combining results from multiple SELECT statements. There are four main types:
Union combines results and eliminates duplicates. Intersect returns only common records. Union All and Intersect All also show duplicate rows. Syntax involves a SELECT query followed by a set operator and another SELECT query.
Concurrency Control in Distributed Database.Meghaj Mallick
The document discusses various techniques for concurrency control in distributed databases, including locking-based protocols and timestamp-based protocols. Locking-based protocols use exclusive and shared locks to control concurrent access to data items. They can be implemented using a single or distributed lock manager. Timestamp-based protocols assign each transaction a unique timestamp to determine serialization order and manage concurrent execution.
Distributed database management systems (DDBMS) allow data to be spread across multiple computer sites connected by a network. A DDBMS provides location transparency so users can access data without knowing its physical location. It also coordinates transactions that involve data stored at multiple sites. DDBMS architectures include transaction managers, data managers, and transaction coordinators to process transactions and subtransactions across distributed data.
This document discusses deadlock prevention by invalidating one of the four conditions necessary for deadlock: mutual exclusion, hold and wait, no preemption, and circular wait. It describes strategies to prevent each condition, such as not requiring mutual exclusion for sharable resources, requesting all resources before execution or only when a process has none to prevent hold and wait, allowing preemption of held resources to prevent no preemption, and imposing a total ordering of resource requests to prevent circular wait. These techniques aim to ensure deadlock is excluded from the beginning.
This document discusses concurrency control algorithms for distributed database systems. It describes distributed two-phase locking (2PL), wound-wait, basic timestamp ordering, and distributed optimistic concurrency control algorithms. For distributed 2PL, transactions lock data items in a growing phase and release locks in a shrinking phase. Wound-wait prevents deadlocks by aborting younger transactions that wait on older ones. Basic timestamp ordering orders transactions based on their timestamps to ensure serializability. The distributed optimistic approach allows transactions to read and write freely until commit, when certification checks for conflicts. Maintaining consistency across distributed copies is important for concurrency control algorithms.
In computer science, divide and conquer is an algorithm design paradigm based on multi-branched recursion. A divide-and-conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type until these become simple enough to be solved directly.
This document discusses deadlock detection and recovery. It defines a wait-for graph to model deadlocks, where transactions that are waiting for resources held by other transactions form a cycle. The system periodically runs an algorithm to check the wait-for graph for cycles indicating deadlocks. If a deadlock is found, the system must select a "victim" transaction to rollback to break the cycle. Factors like work completed and remaining resources needed determine the cost of rolling back each transaction. Rolling back just far enough to break the deadlock is preferred to a full restart. Care must also be taken to avoid repeated rollbacks of the same transaction, a problem known as starvation.
Encapsulation is one of the fundamental concepts of object-oriented programming (OOP). It refers to bundling data and methods that operate on that data within a class. This hides the values and state of the data from outside usage. Encapsulation helps bind data and functions together, hides data from direct access, and makes code more flexible and maintainable by allowing changes without affecting other code. The benefits of encapsulation include increased reusability, reduced complexity by hiding implementation details, and extensibility by allowing updates without changing input/output formats.
This document discusses variants of Turing machines that increase their computational power and proves that any language accepted by a variant Turing machine is also accepted by a standard Turing machine. It covers variants such as multiple tapes, two-way infinite tapes, and nondeterminism. For each variant, it provides a proof that the standard Turing machine is equally powerful by simulating the variant with the standard model.
The document discusses different methods for handling deadlocks in transactional systems, including deadlock prevention, detection, and recovery. It describes two main prevention techniques: pre-declaration ordering and partial ordering of locks. It also covers two timestamp-based prevention schemes called wait-die and wound-wait. For detection, it explains using a wait-for graph to model lock dependencies and detect cycles that indicate a deadlock. Recovery involves selecting a victim transaction to rollback to break the deadlock cycle.
The document discusses transaction processing and ACID properties in databases. It defines a transaction as a group of tasks that must be atomic, consistent, isolated, and durable. It provides examples of transactions involving bank account transfers. It explains the four ACID properties - atomicity, consistency, isolation, and durability. It also discusses transaction states, recovery, concurrency control techniques like two-phase locking and timestamps to prevent deadlocks.
The document describes the job sequencing problem with deadlines and presents a greedy algorithm to solve it. The problem involves scheduling a set of jobs on a single processor to maximize total profit where each job has a deadline and profit. The greedy algorithm sorts jobs by decreasing profit and schedules each job as late as possible while meeting its deadline. This approach always finds the optimal solution that maximizes total profit. Pseudocode and a C++ program implementing the algorithm are also provided.
The document discusses solutions to the critical section problem where multiple processes need exclusive access to shared resources. It defines the critical section problem and requirements for a solution. It then presents three algorithms using shared variables to coordinate access between two processes in a way that satisfies mutual exclusion, progress, and bounded waiting.
Oracle database is a relational database management system. The CREATE TABLE statement is used to create new tables with column names and data types. The ALTER TABLE statement modifies existing table structures by adding, dropping or modifying columns.
This document summarizes a student's research project on improving the performance of real-time distributed databases. It proposes a "user control distributed database model" to help manage overload transactions at runtime. The abstract introduces the topic and outlines the contents. The introduction provides background on distributed databases and the motivation for the student's work in developing an approach to reduce runtime errors during periods of high load. It summarizes some existing research on concurrency control in centralized databases.
The document discusses time and space complexity analysis for algorithms, including using Big O notation to describe an algorithm's efficiency. It provides examples of time complexity for different codes, such as O(n) for a simple loop and O(n^2) for a double loop. The document also covers space complexity and how to estimate the complexity of a problem based on input size constraints.
This document discusses different types of joins in SQL including inner joins, natural joins, left outer joins, and right outer joins. It provides the syntax for each type of join and examples of queries using employee data from emp and emp1 tables. Key details covered include how natural joins form a cartesian product and remove duplicate columns, and that left/right outer joins return all records from one table and matched records from the other table.
The document discusses abstract data types (ADTs) and several common data structures, including stacks, queues, linked lists, trees, and their applications. An ADT defines a data type and operations on that data type without specifying how those operations are implemented. Common programming languages define simple ADTs like integers, while more complex ADTs like lists, stacks and queues must be explicitly defined. The key operations and applications of each data structure are described.
Query Processing : Query Processing Problem, Layers of Query Processing Query Processing in Centralized Systems – Parsing & Translation, Optimization, Code generation, Example Query Processing in Distributed Systems – Mapping global query to local, Optimization,
A distributed file system allows files to be stored on multiple computers that are connected over a network. It implements a common file system that can be accessed by all computers. Key goals are network transparency, so users can access files without knowing their location, and high availability, so files can always be easily accessed regardless of physical location. The main components are a name server that maps file names to locations, and cache managers that store copied of remote files locally to improve performance. Mechanisms like mounting, caching, bulk data transfer, and encryption help build robust distributed file systems.
The document discusses Strassen's algorithm for matrix multiplication. It begins by explaining traditional matrix multiplication that has a time complexity of O(n3). It then explains how the divide and conquer strategy can be applied by dividing the matrices into smaller square sub-matrices. Strassen improved upon this by reducing the number of multiplications from 8 to 7 terms, obtaining a time complexity of O(n2.81). His key insight was applying different equations on the sub-matrix multiplication formulas to minimize operations.
comprehensive lecture on join odering fragments queries. it is the topic of DDBMS and the content are taken from multiple sources including google, book, class lecture.
prepared by IFZAL HUSSAIN student of CS in SHAHEED BENAZIR BHUTTO UNIVERSITY SHERINGAL DIR UPPER KPK, PAKISTAN.
The document discusses data access in .NET applications. It describes how earlier models like DAO and ADO had issues around performance and connectivity. ADO.NET improved on ADO by using a disconnected data access model where connections are opened briefly to perform operations then closed. ADO.NET relies on datasets, which hold in-memory representations of data, and data providers like SQL Client that maintain connections to databases.
This document discusses deadlocks, including the four conditions required for a deadlock, methods to avoid deadlocks like using safe states and Banker's Algorithm, ways to detect deadlocks using wait-for graphs and detection algorithms, and approaches to recover from deadlocks such as terminating processes or preempting resources.
This is an PPT of DBMS. It includes the following topic "Concurrency control ensure consistency & reliability properties of transaction & Deadlock Handling "
Concurrency Control Techniques: Concurrency Control, Locking Techniques for Concurrency
Control, Time Stamping Protocols for Concurrency Control, Validation Based Protocol, Multiple
Granularity, Multi Version Schemes, Recovery with Concurrent Transaction,
This document discusses deadlock detection and recovery. It defines a wait-for graph to model deadlocks, where transactions that are waiting for resources held by other transactions form a cycle. The system periodically runs an algorithm to check the wait-for graph for cycles indicating deadlocks. If a deadlock is found, the system must select a "victim" transaction to rollback to break the cycle. Factors like work completed and remaining resources needed determine the cost of rolling back each transaction. Rolling back just far enough to break the deadlock is preferred to a full restart. Care must also be taken to avoid repeated rollbacks of the same transaction, a problem known as starvation.
Encapsulation is one of the fundamental concepts of object-oriented programming (OOP). It refers to bundling data and methods that operate on that data within a class. This hides the values and state of the data from outside usage. Encapsulation helps bind data and functions together, hides data from direct access, and makes code more flexible and maintainable by allowing changes without affecting other code. The benefits of encapsulation include increased reusability, reduced complexity by hiding implementation details, and extensibility by allowing updates without changing input/output formats.
This document discusses variants of Turing machines that increase their computational power and proves that any language accepted by a variant Turing machine is also accepted by a standard Turing machine. It covers variants such as multiple tapes, two-way infinite tapes, and nondeterminism. For each variant, it provides a proof that the standard Turing machine is equally powerful by simulating the variant with the standard model.
The document discusses different methods for handling deadlocks in transactional systems, including deadlock prevention, detection, and recovery. It describes two main prevention techniques: pre-declaration ordering and partial ordering of locks. It also covers two timestamp-based prevention schemes called wait-die and wound-wait. For detection, it explains using a wait-for graph to model lock dependencies and detect cycles that indicate a deadlock. Recovery involves selecting a victim transaction to rollback to break the deadlock cycle.
The document discusses transaction processing and ACID properties in databases. It defines a transaction as a group of tasks that must be atomic, consistent, isolated, and durable. It provides examples of transactions involving bank account transfers. It explains the four ACID properties - atomicity, consistency, isolation, and durability. It also discusses transaction states, recovery, concurrency control techniques like two-phase locking and timestamps to prevent deadlocks.
The document describes the job sequencing problem with deadlines and presents a greedy algorithm to solve it. The problem involves scheduling a set of jobs on a single processor to maximize total profit where each job has a deadline and profit. The greedy algorithm sorts jobs by decreasing profit and schedules each job as late as possible while meeting its deadline. This approach always finds the optimal solution that maximizes total profit. Pseudocode and a C++ program implementing the algorithm are also provided.
The document discusses solutions to the critical section problem where multiple processes need exclusive access to shared resources. It defines the critical section problem and requirements for a solution. It then presents three algorithms using shared variables to coordinate access between two processes in a way that satisfies mutual exclusion, progress, and bounded waiting.
Oracle database is a relational database management system. The CREATE TABLE statement is used to create new tables with column names and data types. The ALTER TABLE statement modifies existing table structures by adding, dropping or modifying columns.
This document summarizes a student's research project on improving the performance of real-time distributed databases. It proposes a "user control distributed database model" to help manage overload transactions at runtime. The abstract introduces the topic and outlines the contents. The introduction provides background on distributed databases and the motivation for the student's work in developing an approach to reduce runtime errors during periods of high load. It summarizes some existing research on concurrency control in centralized databases.
The document discusses time and space complexity analysis for algorithms, including using Big O notation to describe an algorithm's efficiency. It provides examples of time complexity for different codes, such as O(n) for a simple loop and O(n^2) for a double loop. The document also covers space complexity and how to estimate the complexity of a problem based on input size constraints.
This document discusses different types of joins in SQL including inner joins, natural joins, left outer joins, and right outer joins. It provides the syntax for each type of join and examples of queries using employee data from emp and emp1 tables. Key details covered include how natural joins form a cartesian product and remove duplicate columns, and that left/right outer joins return all records from one table and matched records from the other table.
The document discusses abstract data types (ADTs) and several common data structures, including stacks, queues, linked lists, trees, and their applications. An ADT defines a data type and operations on that data type without specifying how those operations are implemented. Common programming languages define simple ADTs like integers, while more complex ADTs like lists, stacks and queues must be explicitly defined. The key operations and applications of each data structure are described.
Query Processing : Query Processing Problem, Layers of Query Processing Query Processing in Centralized Systems – Parsing & Translation, Optimization, Code generation, Example Query Processing in Distributed Systems – Mapping global query to local, Optimization,
A distributed file system allows files to be stored on multiple computers that are connected over a network. It implements a common file system that can be accessed by all computers. Key goals are network transparency, so users can access files without knowing their location, and high availability, so files can always be easily accessed regardless of physical location. The main components are a name server that maps file names to locations, and cache managers that store copied of remote files locally to improve performance. Mechanisms like mounting, caching, bulk data transfer, and encryption help build robust distributed file systems.
The document discusses Strassen's algorithm for matrix multiplication. It begins by explaining traditional matrix multiplication that has a time complexity of O(n3). It then explains how the divide and conquer strategy can be applied by dividing the matrices into smaller square sub-matrices. Strassen improved upon this by reducing the number of multiplications from 8 to 7 terms, obtaining a time complexity of O(n2.81). His key insight was applying different equations on the sub-matrix multiplication formulas to minimize operations.
comprehensive lecture on join odering fragments queries. it is the topic of DDBMS and the content are taken from multiple sources including google, book, class lecture.
prepared by IFZAL HUSSAIN student of CS in SHAHEED BENAZIR BHUTTO UNIVERSITY SHERINGAL DIR UPPER KPK, PAKISTAN.
The document discusses data access in .NET applications. It describes how earlier models like DAO and ADO had issues around performance and connectivity. ADO.NET improved on ADO by using a disconnected data access model where connections are opened briefly to perform operations then closed. ADO.NET relies on datasets, which hold in-memory representations of data, and data providers like SQL Client that maintain connections to databases.
This document discusses deadlocks, including the four conditions required for a deadlock, methods to avoid deadlocks like using safe states and Banker's Algorithm, ways to detect deadlocks using wait-for graphs and detection algorithms, and approaches to recover from deadlocks such as terminating processes or preempting resources.
This is an PPT of DBMS. It includes the following topic "Concurrency control ensure consistency & reliability properties of transaction & Deadlock Handling "
Concurrency Control Techniques: Concurrency Control, Locking Techniques for Concurrency
Control, Time Stamping Protocols for Concurrency Control, Validation Based Protocol, Multiple
Granularity, Multi Version Schemes, Recovery with Concurrent Transaction,
The document discusses deadlocks in database systems. It defines deadlock as a waiting state where transactions are unable to progress because each is holding a resource needed by another, forming a cyclic dependency. It outlines the four conditions for deadlock - mutual exclusion, hold and wait, no preemption, and circular wait. Methods for handling deadlocks include avoidance, prevention, detection and recovery. Prevention techniques involve locking protocols or transaction rollback with timestamps. Detection uses a wait-for graph to identify cycles indicating deadlocks, and recovery requires selecting victims to rollback to break cycles.
The document discusses concurrency control in database management systems. Concurrency control ensures that transactions are performed concurrently without conflicting results by using methods like locking and timestamps. It prevents issues like lost updates, dirty reads, and non-repeatable reads. The main concurrency control protocols discussed are lock-based protocols using techniques like two-phase locking, and timestamp-based protocols.
Database concurrency control & recovery (1)Rashid Khan
This document discusses concurrency control and recovery in database systems. It covers topics like transactions, concurrency control techniques including locking and timestamp ordering, serializability, recoverability, logging, checkpoints, and recovery techniques like deferred update and immediate update. The goal of concurrency control is to prevent interference between concurrently executing transactions while maintaining consistency and serializability. Recovery techniques aim to restore the database to a consistent state in the event of failures through mechanisms like logging and rollback/rollforward of transactions.
This document discusses the design and development of an advanced database management system using multiversion concurrency control. It begins with an abstract discussing how MVCC allows readers to access shared data without blocking writers by using data versioning. It then covers various concurrency control protocols like lock-based, timestamp-based, and their types. It also discusses techniques for deadlock handling, failure recovery, and remote data backup for catastrophic failures. The document provides details on how MVCC can be implemented to allow concurrent read and write access in a database system.
Design & Development of an Advanced Database Management System Using Multiver...IOSR Journals
The document describes research on developing an advanced database management system using multiversion concurrency control. It discusses how multiversion concurrency control allows readers to continue reading without blocking writers by using data versioning. It also summarizes different concurrency control protocols like lock-based protocols, time stamp ordering protocols, and two-phase locking. The research aims to design a system that uses multiversion concurrency control to provide features like readers that don't block writers and writers that fail fast in a multiprogramming environment.
The document describes research on developing an advanced database management system using multiversion concurrency control. It discusses how multiversion concurrency control allows readers to continue reading without blocking writers by using data versioning. It also summarizes different concurrency control protocols like lock-based and timestamp-based protocols. Lock-based protocols include simplistic, pre-claiming, two-phase locking and strict two-phase locking. Timestamp-based protocols use timestamps to determine the order of transactions. The research also studies methods to prevent deadlocks in the system, such as wait-die and wound-wait schemes.
VALIDATION BASED PROTOCOL AND MULTIPLE GRANULARITY.pptxSamyakJain710491
This document discusses validation based protocol, an optimistic concurrency control technique used in database management systems. It has three phases - read, validation, and write. In the read phase, transactions read data into local variables without updating the database. In the validation phase, a test checks for serializability violations between transactions. If there are no violations, the transaction commits its writes to the database in the write phase. The protocol uses timestamps to order transactions and avoid conflicts. It can avoid cascading rollbacks but has a risk of starvation for long transactions. The document also discusses multiple granularity locking, which defines a hierarchy of data sizes from fine to coarse granularity to control concurrent access.
This document outlines different concurrency control protocols used to ensure serializability of transactions in a database. It discusses lock-based protocols like two-phase locking and tree protocols. It also covers timestamp-based protocols that assign timestamps to transactions and validate reads/writes based on timestamp order. Validation-based protocols execute transactions optimistically and validate during a separate validation phase if updates can be committed without violating serializability.
This document discusses various concurrency control techniques for managing concurrent access to shared data in databases and transaction systems. It covers lock-based protocols that use locking to control access, timestamp-based protocols that use timestamps to order transactions, and techniques for handling deadlocks. The key lock-based protocols covered are two-phase locking and lock conversions. Timestamp-based protocols discussed include timestamp ordering and Thomas' write rule. Deadlock handling techniques include prevention, detection, and recovery.
Deadlocks can occur in distributed database systems when transactions are waiting for data locked by other transactions across multiple sites. There are three main approaches to handle deadlocks - prevention, avoidance, and detection/removal. For avoidance and detection/removal, issues like transaction location and control must be addressed due to the distributed nature. Avoidance algorithms abort or wait transactions based on age to prevent deadlocks proactively. Detection builds global wait-for-graphs to identify deadlock cycles and remove the deadlock.
Deadlocks can occur in distributed database systems when transactions are waiting for data locked by other transactions across multiple sites. There are three main approaches to handle deadlocks - prevention, avoidance, and detection/removal. For avoidance and detection/removal, issues like transaction location and control must be addressed due to the distributed nature. Avoidance algorithms abort or wait younger transactions depending on a distributed wait-die or wound-wait approach. Detection builds global wait-for-graphs to detect cycles indicating deadlocks across sites.
The document discusses locking techniques and timestamp ordering for concurrency control in database systems. It provides details on shared locks and exclusive locks for concurrency control. Timestamp ordering assigns each transaction a unique timestamp based on when it enters the system. The timestamp ordering protocol ensures serializability by only allowing schedules where transactions execute in timestamp order. It compares the timestamp of transactions to the read and write timestamps of data items to determine if operations can be executed or if transactions need to be aborted. While timestamp ordering ensures serializability and avoids deadlocks, it does not prevent cascading rollbacks when transactions rely on each other.
Concurrency Control in Distributed Systems.pptxMArshad35
Concurrency control in distributed systems allows multiple transactions to execute simultaneously by coordinating access to shared data. There are several concurrency control algorithms like two-phase locking and timestamp ordering that prevent interference between transactions. Two-phase locking works by acquiring locks before reads/writes and releasing them after transaction completion. Timestamp ordering assigns timestamps to transactions and ensures serializability. Optimistic concurrency control allows transactions to run without locking by checking for conflicts at commit time and aborting transactions if conflicts exist. Concurrency control aims to maximize throughput while maintaining consistency across distributed transactions.
The document discusses various concurrency control protocols used to maintain database consistency with concurrent transaction execution. It describes lock-based protocols that use locks to control transaction access to shared data, including two-phase locking and various lock types. It also summarizes timestamp-based and validation-based protocols as alternative approaches to concurrency control.
Similar to DBMS (Deadlock, deadlock prevention, 2phase locking) (20)
Cricket management system ptoject report.pdfKamal Acharya
The aim of this project is to provide the complete information of the National and
International statistics. The information is available country wise and player wise. By
entering the data of eachmatch, we can get all type of reports instantly, which will be
useful to call back history of each player. Also the team performance in each match can
be obtained. We can get a report on number of matches, wins and lost.
Covid Management System Project Report.pdfKamal Acharya
CoVID-19 sprang up in Wuhan China in November 2019 and was declared a pandemic by the in January 2020 World Health Organization (WHO). Like the Spanish flu of 1918 that claimed millions of lives, the COVID-19 has caused the demise of thousands with China, Italy, Spain, USA and India having the highest statistics on infection and mortality rates. Regardless of existing sophisticated technologies and medical science, the spread has continued to surge high. With this COVID-19 Management System, organizations can respond virtually to the COVID-19 pandemic and protect, educate and care for citizens in the community in a quick and effective manner. This comprehensive solution not only helps in containing the virus but also proactively empowers both citizens and care providers to minimize the spread of the virus through targeted strategies and education.
This is an overview of my current metallic design and engineering knowledge base built up over my professional career and two MSc degrees : - MSc in Advanced Manufacturing Technology University of Portsmouth graduated 1st May 1998, and MSc in Aircraft Engineering Cranfield University graduated 8th June 2007.
Sri Guru Hargobind Ji - Bandi Chor Guru.pdfBalvir Singh
Sri Guru Hargobind Ji (19 June 1595 - 3 March 1644) is revered as the Sixth Nanak.
• On 25 May 1606 Guru Arjan nominated his son Sri Hargobind Ji as his successor. Shortly
afterwards, Guru Arjan was arrested, tortured and killed by order of the Mogul Emperor
Jahangir.
• Guru Hargobind's succession ceremony took place on 24 June 1606. He was barely
eleven years old when he became 6th Guru.
• As ordered by Guru Arjan Dev Ji, he put on two swords, one indicated his spiritual
authority (PIRI) and the other, his temporal authority (MIRI). He thus for the first time
initiated military tradition in the Sikh faith to resist religious persecution, protect
people’s freedom and independence to practice religion by choice. He transformed
Sikhs to be Saints and Soldier.
• He had a long tenure as Guru, lasting 37 years, 9 months and 3 days
3. Deadlock
• In a multi-process system, deadlock is an unwanted situation that arises in a shared
resource environment, where a process indefinitely waits for a resource that is held
by another process.
• For example, assume a set of transactions {T0, T1, T2, ..., Tn}. T0 needs a resource
X to complete its task. Resource X is held by T1, and T1 is waiting for a resource Y,
which is held by T2. T2 is waiting for resource Z, which is held by T0. Thus, all the
processes wait for each other to release resources. In this situation, none of the
processes can finish their task. This situation is known as a deadlock.
• Deadlocks are not healthy for a system. In case a system is stuck in a deadlock, the
transactions involved in the deadlock are either rolled back or restarted
4. Deadlock Prevention
• To prevent any deadlock situation in the system, the DBMS aggressively
inspects all the operations, where transactions are about to execute. The
DBMS inspects the operations and analyzes if they can create a deadlock
situation. If it finds that a deadlock situation might occur, then that
transaction is never allowed to be executed.
• There are deadlock prevention schemes that use timestamp ordering
mechanism of transactions in order to predetermine a deadlock situation.
5. Wait-Die Scheme
• In this scheme, if a transaction requests to lock a resource (data item), which is already held with
a conflicting lock by another transaction, then one of the two possibilities may occur −
• If TS(Ti) < TS(Tj) − that is Ti, which is requesting a conflicting lock, is older than Tj − then Ti is
allowed to wait until the data-item is available.
• If TS(Ti) > TS(tj) − that is Ti is younger than Tj − then Ti dies. Ti is restarted later with a
random delay but with the same timestamp.
• This scheme allows the older transaction to wait but kills the younger one.
6. Wound-Wait Scheme
• In this scheme, if a transaction requests to lock a resource (data item), which is already held with conflicting lock by some
another transaction, one of the two possibilities may occur −
• If TS(Ti) < TS(Tj), then Ti forces Tj to be rolled back − that is Ti wounds Tj. Tj is restarted later with a random delay but
with the same timestamp.
• If TS(Ti) > TS(Tj), then Ti is forced to wait until the resource is available.
• This scheme, allows the younger transaction to wait; but when an older transaction requests an item held by a younger one,
the older transaction forces the younger one to abort and release the item.
• In both the cases, the transaction that enters the system at a later stage is aborted.
7. Intent Lock
• The Database Engine uses intent locks to protect placing a shared (S) lock or exclusive (X)
lock on a resource lower in the lock hierarchy. Intent locks are named intent locks because
they are acquired before a lock at the lower level, and therefore signal intent to place locks at
a lower level.
• Intent locks serve two purposes:
• To prevent other transactions from modifying the higher-level resource in a way that would
invalidate the lock at the lower level.
• To improve the efficiency of the Database Engine in detecting lock conflicts at the higher
level of granularity.
8. Intent Lock
• For example, a shared intent lock is requested at the table level before shared (S)
locks are requested on pages or rows within that table. Setting an intent lock at the
table level prevents another transaction from subsequently acquiring an exclusive
(X) lock on the table containing that page. Intent locks improve performance
because the Database Engine examines intent locks only at the table level to
determine if a transaction can safely acquire a lock on that table. This removes the
requirement to examine every row or page lock on the table to determine if a
transaction can lock the entire table.
• Intent locks include intent shared (IS), intent exclusive (IX), and shared with intent
exclusive (SIX).
9. Isolation
• Isolation, in the context of databases, specifies when and how the changes
implemented in an operation become visible to other parallel operations.
Transaction isolation is an important part of any transactional system. It
deals with consistency and completeness of data retrieved by queries un
affecting a user data by other user actions. A database acquires locks on data
to maintain a high level of isolation.
10. 2 Phase Locking Protocol
• T1 & T2 conflict in A,B,C
• Both must get 3 locks to complete.
• If T1 gets all 3 now, T2 must get them all before or all after.
• So with respect to conflict items, the schedule will be serial.
11. Growing Phase
• Can only LOCK items during this Phase.
• May also UPGRADE
• May also Read & Write once items are locked.
• NO UNLOCKING in this phase
• If Transaction is successful, it gets all its locks.
• If Transaction is not successful, it may deadlock or fail because it cannot
get a lock.
12. Shrinking Phase
• Can only UNLOCK items during this Phase.
• May also DOWNGRADE
• May still Read & Write items which are still locked.
• Phase begins with FIRST UNLOCK
• NO LOCK after first unlock
• This Phase cannot fail, but transaction may still fail because of Dirty Read
• If no Dirty Read, transaction will be serial.
雅虎竞拍
煤炉代买
paypay商城
乐天二手
日本亚马逊
乐天新品
ZOZOTOWN
