CN102929711B - A kind of implementation method of real-time transactional memory of software - Google Patents
A kind of implementation method of real-time transactional memory of software Download PDFInfo
- Publication number
- CN102929711B CN102929711B CN201210358174.6A CN201210358174A CN102929711B CN 102929711 B CN102929711 B CN 102929711B CN 201210358174 A CN201210358174 A CN 201210358174A CN 102929711 B CN102929711 B CN 102929711B
- Authority
- CN
- China
- Prior art keywords
- task
- queue
- rollback
- time
- internal memory
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Fee Related
Links
- 230000015654 memory Effects 0.000 title claims abstract description 76
- 238000000034 method Methods 0.000 title claims abstract description 25
- 230000000284 resting effect Effects 0.000 claims description 6
- 235000013399 edible fruits Nutrition 0.000 claims description 3
- 238000001514 detection method Methods 0.000 description 6
- 230000004048 modification Effects 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000000903 blocking effect Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000002123 temporal effect Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 238000000151 deposition Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000012805 post-processing Methods 0.000 description 1
- 230000035484 reaction time Effects 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
- 238000005096 rolling process Methods 0.000 description 1
Landscapes
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
nullThe invention discloses the implementation method of a kind of real-time transactional memory of software，By defining maximum rollback number of times，Therefore the time performing transaction internal memory code can ensure that within the specific limits，And the obstruction that low priority task causes occurs in both cases，A kind of situation is that task is when just dispatch，Another kind of situation be to occur at task order to head of the queue be waken up when，But in both cases，The maximum obstruction time be all low priority task perform a transaction internal memory time (or submit to，Or rollback，Take in both the most time-consuming that)，This maximum obstruction time is to elect from the maximum of all tasks carrying transaction internal memories lower than current task priority，Owing to the task quantity in queue is fixing，Therefore，The worst execution time of task the most just can limit within the specific limits.
Description
Technical field
The present invention relates to the embedded real-time operating system of computer realm, particularly to one for embedded
A kind of implementation method of real time operating system real-time transactional memory of software.
Technical background
Embedded real time system refers to there is the strict operating system limited for the task process time.If appointed
The process time of business exceedes the off period (deadline), may produce serious consequence.Real-time is divided into firmly
In real time and soft in real time, in hard real-time system, if task run time time-out can produce the most serious after
Really, in soft real-time system, then can have an impact, but will not be the most serious.
Transaction internal memory (Transactional Memory) is that in operating system, multitask exclusive reference shares number
According to a kind of mode.In traditional operating system, it is achieved the method sharing data exclusive reference usually makes
Ensure with spin lock (Spinlock).Under this implementation, task get shared
Firstly the need of obtaining a lock before resource, if it detects that this lock is got by other tasks,
The most just it is circulated till waiting until that this lock is released.This mode disadvantageously, if there is
Multiple tasks accessing shared data simultaneously, then their access is that serial is carried out.Compare at data contention
In the environment of fierceness, this mode compares poor efficiency.The implementation of transaction internal memory is the most different, task
The existence of other tasks can't be detected before entering into critical zone, but be previously recorded entering critical zone
The state of processor once, then carries out collision detection performing critical zone or performed critical zone when.
If it occur that conflict, then just various states (value of depositor and the value of shared data etc.) are returned to
Before entering into critical zone, then re-executing, this operation is called rollback.Without conflict, then
Just being written to the content of amendment share in data, this operation is called submission.This mode and spin lock
Difference is, when multiple task accessing shared data, multiple tasks can perform critical zone together, is one
Plant parallel form.The environment that competition is fiercer (namely has a lot of task and accesses critical simultaneously
District), transaction internal memory compares spin lock bigger advantage.The operation principle of transaction internal memory is referred to Fig. 1.
The implementation of affairs can be divided into hardware transactional internal memory and software transaction internal memory, the most only considers software transaction
Internal memory, also has, and process proposed herein can realize on uniprocessor, it is also possible at the ring of multiprocessor
Realize under border.Realizing if in the environment of processor, task can only be run on the processor that it is affiliated,
Can not move on other processors.
Transaction internal memory is mainly made up of two processes: collision detection and management (conflict detection and
And version management (version management) management).Collision detection is responsible for detection in things
The when that internal memory running, things internal memory with other clashes, and conflict management is responsible for occurring in conflict
Which with the part of post processing conflict, if two transaction internal memories there occurs conflict, this part judge by
Individual transaction internal memory continues to run with.The content of amendment is saved in daily record on being in fact by the operation logic of things internal memory
In, the most again the content write of amendment is shared in data, if it occur that conflicted also if successfully have submitted
And judged to need rollback by conflict management decision, then the content in abort log, then recover processor ring
Border, or in turn, content original for shared data is saved in daily record, by daily record when of rollback
Content recovery in shared data.These are all the parts that version management needs to be responsible for.
Having been described above, in real-time system, it is more serious that the operation time time-out of task may produce ratio
Consequence.So generally in the realization of real-time system, it is necessary to ensure the predictability of task time.But
In the realization of usual transaction internal memory, task perform critical zone when may rollback many times,
Even unlimited rollback.This situation is unacceptable in real-time system.
Summary of the invention
For above-mentioned technological deficiency, the present invention proposes the implementation method of real-time transactional memory of software.
In order to solve above-mentioned technical problem, technical scheme is as follows:
The implementation method of real-time transactional memory of software, comprises the steps:
11) according to whether producing conflict between task, the conflict relationship figure between generation task, and according to this
All tasks are divided into several queue by conflict relationship figure, and each task belongs to and can only belong to a queue;
12) adding a constant, described constant defines the maximum rollback number of times of task, if certain task rollback time
This task beyond this constant, is then joined in its belonging queue by number, and the tail of the queue in this queue is carried out
Queuing up, and task can enter into resting state, only when this task order to head of the queue when, this task is
Can be waken up, then re-execute the code of transaction internal memory;
If once there being two tasks to clash, then process according to following two situation:
13) being aligned in head of the queue when one of them task, another one task is not in queue, then the most just
The task rollback preferentially allowed not in queue, so guarantees that the task of head of the queue can be submitted to, if this task is returned
When the number of times of rolling has reached the number of times that described constant specifies, then it will enter in the queue that it is affiliated
Row is queued up, and enters into resting state, and wait wakes up up;
14) if two tasks all do not have in queue, then the priority according to which task is high, make priority high
Tasks carrying, the then rollback of another task, and if having the rollback number of times of task to reach described constant
During the number of times specified, then this task just joins the queue that it is affiliated.
Further, if on one processor, when a low priority task is carrying out transaction internal memory
During code, if there being high-priority task to arrive, then this high-priority task needs to wait that low priority is appointed
The transaction internal memory of business is submitted to or just can seize low priority task after rollback.
The beneficial effects of the present invention is: according to the method described above, the execution time of task can be divided into four portions
Point: perform non-transactional memory part time, perform transaction internal memory code time (comprise the execution time,
Rollback time and submission time), the queuing time in the blocking time of low priority task and queue.Perform non-
The time of transaction internal memory part is constant, so being fixing.Owing to having defined maximum rollback number of times,
Therefore the time performing transaction internal memory code can ensure that within the specific limits, and low priority task is made
The obstruction become occurs in both cases, and a kind of situation is task when just dispatch, and another kind of situation is
Occur task be aligned to head of the queue be waken up when, but in both cases, the maximum obstruction time is all
It is that low priority task performs time of a transaction internal memory and (or submits to, or rollback, take both
In the most time-consuming that), this maximum obstruction time is from all tasks lower than current task priority
The maximum of execution transaction internal memory is elected.Owing to the task quantity in queue is fixing, therefore
Task queuing time in queue is also fixing, its maximum be exactly all belong in this queue its
His tasks carrying transaction internal memory and the temporal summation submitted to.Therefore, the worst execution time of task is also with regard to energy
Enough restrictions are within the specific limits.
Accompanying drawing explanation
Fig. 1 (a) is the schematic diagram of spin lock；
Fig. 1 (b) is the schematic diagram of transaction internal memory；
Fig. 2 (a) is the conflict relationship figure of task；
Fig. 2 (b) is distribution queue figure；
Fig. 3 is metadata graph；
Fig. 4 is STM_Start flow chart；
Fig. 5 is STM_Read flow chart；
Fig. 6 is STM_Commit flow chart；
Fig. 7 is STM_Conflict flow chart.
Detailed description of the invention
Below in conjunction with the drawings and specific embodiments, the present invention is described further.
In this article, the most simply consider that a task comprises a transaction internal memory.Namely in affairs
Deposit and link together with a task.So sometimes may use " task " replacement " in affairs
Deposit ".Say the transaction internal memory rollback in the task that task rollback refers to herein.
TL2 is the transaction internal memory implementation that a kind of comparison is classical, and it is used in general operation system.Herein
Summary of the invention be on the basis of this software transaction internal memory of TL2 improve a kind of real-time transactional memory of software.
Due to this transaction internal memory realize relatively simple, therefore have employed it as realizing framework, and do thereon
Some little changes.But thought herein is not limited to this software transaction internal memory.
(1) first, according to whether producing conflict one task conflict graph of a relation of picture between task.In figure
Node is exactly task, if two tasks may produce conflict, then just the two node is drawn a limit.
An example is given below, and as shown in table 1, if there being 5 tasks in system, and the data of task are visited
Ask that content is the most as shown in table 1, then the conflict relationship figure between task can be drawn, as shown in Fig. 2 (a).
It will be seen that owing to task T1 and T2 have accessed data a1, a2 simultaneously, and access the two variable
Time the most at least one be to write, so T1 and T2 has connected a limit.And for variable a3, T1 and T2
Being to read, and T3 is to write, therefore T3 has connected a limit respectively with T1 and T2.And give another here
Individual data structure is to realize real-time transactional memory of software, and this data structure is exactly shown in queue such as Fig. 2 (b).
Every same UNICOM subgraph interior joint that is in all distributes in same queue, say, that every be in
Two tasks inside one queue are all possible to produce conflict.This is a kind of conservative method, because
Just have conflict between two nodes being only connected in the drawings, but two nodes in queue are likely
Linked up by other nodes in figure, actually the two node not conflict itself.
The access content of table 1 task
| Task | Access content |
| T1 | Read a1, read and write a2, read a3, read a4 |
| T2 | Write a1, read and write a2, read a3 |
| T3 | Write a3, write a4 |
| T4 | Read a5 |
| T5 | Write a5 |
(2) constant (MaxAbortNumber) and a queue are added.This constant defines appoints
The maximum rollback number of times of business.If after this number of times of certain task rollback, then it will join its institute
In the queue belonged to, the tail of the queue in this queue is ranked, and task can enter into resting state.Only
Having when task order to head of the queue when, this task just can be waken up up, then by the upper task of being discharged to head of the queue
Re-execute the code of transaction internal memory.If once having two tasks to clash, then to have following two
Situation:
1. one of them task is aligned in head of the queue, and another one task is not in queue.The most at this time
The most preferentially allow the task rollback of head of the queue, since it is desired that ensure task most rollback MaxAbortNumber time, institute
Have to submit to successfully with the task of head of the queue.Another does not has the task in queue with regard to rollback, if this
The number of times of business rollback has reached MaxAbortNumber time, then this task will enter into the queue that it is affiliated
In rank, and enter into resting state, wait wakes up up.
If 2. two tasks all do not have in queue, then at this time conflict management strategy is accomplished by which is seen
The priority of task is high, allows the tasks carrying that priority is high, so compares the demand meeting real-time system.And
And if have the rollback number of times of task to reach MaxAbortNumber time, then this task just joins its institute
The queue belonged to.
Two tasks the most not producing conflict all occur in the situation of head of the queue, and being because this situation is
It is unlikely that.The queue division methods above carried according to Yin, every may produce conflict two
Task is necessarily in inside same queue.
(3) also need to consider a problem, likely by Gao You tasks carrying transaction internal memory code when
First level task preemption.If high-priority task is when certain low priority task runs transaction internal memory code
Time is robbed and be account for it, and two tasks are on same processor, and at this time processor can not be given low excellent
First level task, this low priority task can not rollback, high-priority task can not perform, thus backward
Create deadlock.Generation in order to avoid this situation, it is proposed that the solution of a kind of " delay dispatching ".
If on one processor, a low priority task is had to be carrying out transaction internal memory code, the most such as
Fruit has high-priority task to arrive, then in this high-priority task needs the affairs of wait low priority task
Low priority task just can be seized after depositing submission or rollback.Namely high-priority task multipotency is low
Priority tasks blocks the time (no matter the result of this time is to submit to or rollback) performing a transaction internal memory.
Firstly, it is necessary to consider the metadata (Metadata) of transaction internal memory, they are to realize software transaction internal memory
Some Data Structures.Just for adding an ObjectHeader on the basis of the metadata of TL2.
Each sharing data objects has an ObjectHeader the most corresponding, and transaction internal memory is at accessing shared data
When first have to access this ObjectHeader.If as it is shown on figure 3, ObjectHeader first
The first place in territory is 0, then illustrate that it is not locked by other tasks, then its remaining position is exactly indication data
Version number, this version number is used for judging that data are either with or without being modified.If 1, then this is described
Data are pinned by other tasks, and at this time remaining is exactly the task pointer pointing to and pinning these data.
This realize with TL2 is consistent.Second territory is directed to share the pointer of data.Territory below is one
Individual visible reader's list (visible reader list), it can be seen which has appoint inside this list
Do honest work and reading these shared data.Task for whole system has carried out a numbering, for each task
For, simply use a bit to represent in visible reader list, such as task 1 corresponds to
First bit, task 2 is corresponding to second bit, the most by that analogy.The variable of one 32 is permissible
Represent 32 tasks, reason for this is that to save space.Why need to increase so one territory,
It is because the task at head of the queue and may produce conflict and the rollback of " implicit expression " with other tasks.Can because having
The data modification that head of the queue task was read the when of submission to by other tasks of energy, the task of such head of the queue is accomplished by
Rollback, this situation is unallowed.So it is to be appreciated that data by which task were read.And have
After this visibility list, avoid the need for reading daily record, it is only necessary to write daily record.
In general, software transaction internal memory has several relatively common API:STM_Start, STM_Read,
STM_Write,STM_Commit,STM_Conflict。
STM_Start calls at first at every section of transaction internal memory code, and flow chart is as shown in Figure 4.
First, if the rollback number of times of task has reached MaxAbortNumber, then just task is joined and it
In corresponding queue, and task enters into sleep state, concedes processor.Without reaching
MaxAbortNumber, then just carry out, with regard to following, the certain operations that transaction internal memory normally starts, such as preserve
Buffer status, will write daily record and reset, by state initialization of transaction internal memory etc..
STM_Read and STM_Write is used in transaction internal memory read-write and shares the API of data.Fig. 5 shows
Having shown the process of STM_Read, its input parameter is the pointer of current task and needs the address read, and returns
Returning value is the content read, and it is all to need to use STM_Read that data are shared in the reading in transaction internal memory operates
Carry out.The difference of the STM_Read in STM_Read and TL2 here is, it eliminates checking
Current task the most effective process (namely detecting the address of reading either with or without being modified), because
Other tasks are it can be seen that the address read of current task, if producing conflict, submitting to when that
Business will be called STM_Conflict and be solved conflict.The most here the detection of conflict it is made without.Here
The flow chart of STM_Write is not drawn, because its operation is substantially one with the operation in TL2
Sample, in addition to a bit, it needs to detect whether current task has been labeled as " abort ", as
Fruit is, then it is accomplished by rollback, if not, then just carry out just according to common operation.Its
In also have API, namely a STM_Abort, its effect is exactly the transaction internal memory of rollback appointed task,
Primary operational is exactly version number and the content of registers recovering to share data, and by visible reader's list
Corresponding positions clearing etc..
STM_Commit is used to submit to the API of transaction internal memory amendment content, and it is the end at transaction internal memory
The API called.The process of STM_Commit is as shown in Figure 6.First time its process is more complicated,
Go through and write daily record (write log), check and write the ObjectHeader that the address occurred in daily record is corresponding, first
Checking whether ObjectHeader is locked, if locked, illustrating that other task is also writing this address.
From ObjectHeader, the most just extract the pointer of competition task and call STM_Conflict
Solve this conflict.Without being locked, then check in visible reader's list of ObjectHeader and be
No existence competition task, if it has, extract the numbering of these tasks the most respectively out, and calls
STM_Conflict solves conflict.If it is determined that current task can continue to, then just by iterator back
Walk, continue to attempt to lock current task, be the most so recycled to competition task and perceived and be abandoned
Meeting rollback also unlocks this object.If the judged result of STM_Conflict is to allow current task continue executing with,
So attempt to lock next data object.Note, lock to object and record the version number before locking
It it is the process of an atomicity.If STM_Conflict judges Current transaction internal memory rollback, then just terminate.
If above-mentioned steps can be passed through, just the content write in daily record is write back to internal memory.Then will write in daily record
Hold and unlock and enclose new version number, the ObjectHeader that namely amendment object is corresponding.Finally, as
Really Current transaction internal memory is at head of the queue, then just remove this task from head of the queue, if queue also has element,
Just wake up the next element in queue, the newest head of the queue element up.The concordance of queue operation is to use
Spin lock ensures.
This API of STM_Conflict is used to process an API of conflict, namely realizes noted earlier
Conflict management part.As it is shown in fig. 7, it is it is first determined whether wherein there is the rollback number of times of a task to reach
Having arrived MaxAbortNumber, if reached, having illustrated that this task is in queue, then with regard to rollback another
The transaction internal memory of individual task.If the rollback number of times of two transaction internal memories is all not reaching to MaxAbortNumber,
The most just determining which task continues executing with according to priority, which rollback, this meets system in real time
The demand of system, pays the utmost attention to high-priority task.If needing rollback to compete task, merely just will competition
Task flagging is " abort ", does not directly invoke STM_Abort and goes rollback to compete task.Because competition
It has been " abort " that task all can detect whether calling STM_Read or STM_Write when,
If it is, its own will rollback.
According to the method described above, the execution time of task can be divided into four parts: performs non-transactional memory part
Time, perform transaction internal memory code time (comprising execution time, rollback time and submission time), low
Queuing time in the blocking time of priority tasks and queue.Owing to having defined maximum rollback number of times,
Therefore the time performing transaction internal memory code can ensure that within the specific limits.And low priority task is made
The obstruction become occurs in both cases, and a kind of situation is task when just dispatch, and another kind of situation is
Occur task be aligned to head of the queue be waken up when, but in both cases, the maximum obstruction time is all
Being the time of a low priority task transaction internal memory of execution, this maximum obstruction time is than current from all
The maximum of the tasks carrying transaction internal memory that task priority is low is elected.Due to the task in queue
Quantity is fixing, and therefore task queuing time in queue is also fixing, and its maximum is exactly queue
In every other tasks carrying transaction internal memory and the temporal summation submitted to.Therefore, task the worst reaction time
Between the most just can limit within the specific limits.
The above is only the preferred embodiment of the present invention, it is noted that common for the art
Technical staff, without departing from the inventive concept of the premise, it is also possible to make some improvements and modifications, these
Improvements and modifications also should be regarded as in scope.
Claims (2)
1. the implementation method of a real-time transactional memory of software, it is characterised in that comprise the steps:
11) according to whether producing conflict between task, the conflict relationship figure between generation task, and
According to this conflict relationship figure, all tasks being divided into several queue, each task belongs to and can only belong to
One queue；
12) adding a constant, described constant defines the maximum rollback number of times of task, if certain is appointed
This task beyond this constant, is then joined in its belonging queue, in this queue by business rollback number of times
Tail of the queue rank, and this task can enter into resting state, only when this task order is to head of the queue
When, this task just can be waken up, and then re-executes the code of transaction internal memory；
If once there being two tasks to clash, then process according to following two situation:
13) being aligned in head of the queue when one of them task, another one task is not in queue, then
The task rollback the most preferentially allowed not in queue, so guarantees that the task of head of the queue can be submitted to, as
When the number of times of the fruit not task rollback in queue has reached the number of times that described constant specifies, then it will
Entering in the queue that it is affiliated and rank, and enter into resting state, wait wakes up up；
14) if two tasks all do not have in queue, then the priority according to which task is high, allows excellent
The tasks carrying that first level is high, the then rollback of another task, and if performing the rollback of task in rollback
When number of times has reached the number of times that described constant specifies, then this task just joins the queue that it is affiliated.
The implementation method of a kind of real-time transactional memory of software the most according to claim 1, its feature exists
In, if on one processor, when a low priority task is carrying out transaction internal memory code,
If there being high-priority task to arrive, then this high-priority task needs to wait the thing of low priority task
Business internal memory is submitted to or just can seize low priority task after rollback.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201210358174.6A CN102929711B (en) | 2012-09-24 | 2012-09-24 | A kind of implementation method of real-time transactional memory of software |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201210358174.6A CN102929711B (en) | 2012-09-24 | 2012-09-24 | A kind of implementation method of real-time transactional memory of software |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN102929711A CN102929711A (en) | 2013-02-13 |
| CN102929711B true CN102929711B (en) | 2016-08-10 |
Family
ID=47644518
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201210358174.6A Expired - Fee Related CN102929711B (en) | 2012-09-24 | 2012-09-24 | A kind of implementation method of real-time transactional memory of software |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN102929711B (en) |
Families Citing this family (8)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN105243097A (en) * | 2015-09-11 | 2016-01-13 | 中国人民解放军63796部队 | Method for determination and concurrent control of priority of real-time transactions in aerospace measurement and control database |
| CN109901913B (en) * | 2017-12-11 | 2023-08-22 | 复旦大学 | Multithread transaction storage programming model method capable of controlling repeated execution times |
| CN110275770B (en) * | 2018-03-15 | 2023-09-22 | 阿里巴巴集团控股有限公司 | Task balanced scheduling method, system, node and electronic equipment |
| CN110837411B (en) * | 2019-11-08 | 2023-05-12 | 敏博科技(武汉)有限公司 | Method and system for concurrent I/O scheduling in data server side partition |
| CN111158890A (en) * | 2020-01-20 | 2020-05-15 | 北京一流科技有限公司 | System and method for controlling task parallelism in task set |
| CN113360256A (en) * | 2020-03-06 | 2021-09-07 | 烽火通信科技股份有限公司 | Thread scheduling method and system based on control plane massive concurrent messages |
| CN114035928B (en) * | 2021-11-26 | 2024-07-30 | 重庆富民银行股份有限公司 | Distributed task allocation processing method |
| CN117076145B (en) * | 2023-08-22 | 2024-02-23 | 电子科技大学 | Safe and efficient STM synchronization method based on fine-granularity read-write lock |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7730491B2 (en) * | 2005-08-30 | 2010-06-01 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
| CN101510162B (en) * | 2009-03-26 | 2011-11-02 | 浙江大学 | Software transaction internal memory implementing method based on delaying policy |
| US20120005684A1 (en) * | 2010-07-02 | 2012-01-05 | Fiji Systems, Inc. | Priority rollback protocol |
-
2012
- 2012-09-24 CN CN201210358174.6A patent/CN102929711B/en not_active Expired - Fee Related
Also Published As
| Publication number | Publication date |
|---|---|
| CN102929711A (en) | 2013-02-13 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN102929711B (en) | A kind of implementation method of real-time transactional memory of software | |
| Wang et al. | Mostly-optimistic concurrency control for highly contended dynamic workloads on a thousand cores | |
| US8417897B2 (en) | System and method for providing locale-based optimizations in a transactional memory | |
| Ramadan et al. | Dependence-aware transactional memory for increased concurrency | |
| Ren et al. | Lightweight locking for main memory database systems | |
| US8438568B2 (en) | Speculative thread execution with hardware transactional memory | |
| Rossbach et al. | TxLinux: Using and managing hardware transactional memory in an operating system | |
| CN101452400B (en) | Method and system for processing transaction buffer overflow in multiprocessor system | |
| US7962923B2 (en) | System and method for generating a lock-free dual queue | |
| AU2016244128B2 (en) | Processing database transactions in a distributed computing system | |
| US8694706B2 (en) | System and method for NUMA-aware locking using lock cohorts | |
| JP5635620B2 (en) | Performing mode switching in an infinite transactional memory (UTM) system | |
| US8689221B2 (en) | Speculative thread execution and asynchronous conflict events | |
| US8775837B2 (en) | System and method for enabling turbo mode in a processor | |
| US20130290967A1 (en) | System and Method for Implementing NUMA-Aware Reader-Writer Locks | |
| US20120005530A1 (en) | System and Method for Communication Between Concurrent Transactions Using Transaction Communicator Objects | |
| US7945741B2 (en) | Reservation required transactions | |
| CN104487946A (en) | Method, apparatus, and system for adaptive thread scheduling in transactional memory systems | |
| JP2003044452A (en) | Method and system for packaging synchronous memory barrier | |
| Dhoked et al. | An adaptive approach to recoverable mutual exclusion | |
| Padhye et al. | Scalable transaction management with snapshot isolation on cloud data management systems | |
| CN109901913B (en) | Multithread transaction storage programming model method capable of controlling repeated execution times | |
| Kim et al. | $ C\!\!-\!\! Lock $: Energy Efficient Synchronization for Embedded Multicore Systems | |
| Ren et al. | High-performance GPU transactional memory via eager conflict detection | |
| Duan et al. | Asymmetric memory fences: Optimizing both performance and implementability |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant | ||
| CF01 | Termination of patent right due to non-payment of annual fee | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20160810 |