CN102929711A - Implementing method of real-time transactional memory of software - Google Patents
Implementing method of real-time transactional memory of software Download PDFInfo
- Publication number
- CN102929711A CN102929711A CN2012103581746A CN201210358174A CN102929711A CN 102929711 A CN102929711 A CN 102929711A CN 2012103581746 A CN2012103581746 A CN 2012103581746A CN 201210358174 A CN201210358174 A CN 201210358174A CN 102929711 A CN102929711 A CN 102929711A
- Authority
- CN
- China
- Prior art keywords
- task
- time
- internal memory
- rollback
- formation
- 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.)
- Granted
Links
- 230000015654 memory Effects 0.000 title claims abstract description 79
- 238000000034 method Methods 0.000 title claims abstract description 29
- 230000015572 biosynthetic process Effects 0.000 claims description 44
- 238000005755 formation reaction Methods 0.000 claims description 44
- 238000010586 diagram Methods 0.000 description 8
- 238000001514 detection method Methods 0.000 description 5
- 230000004048 modification Effects 0.000 description 4
- 238000012986 modification Methods 0.000 description 4
- 230000000903 blocking effect Effects 0.000 description 2
- 230000002123 temporal effect Effects 0.000 description 2
- 241001269238 Data Species 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000035484 reaction time Effects 0.000 description 1
- 238000011084 recovery Methods 0.000 description 1
Images
Landscapes
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses an implementing method of real-time transactional memory of software. Because a maximum number of roll-back is limited, the time for executing a transactional memory code can be guaranteed to be maintained in a certain range; blockage caused by a low-priority task occurs under two conditions, the first condition is that the blockage occurs when the task is just scheduled, and the other condition is that the blockage occurs when the task is arrayed at the head of a queue and awakened; a maximum blockage time is always the time for the low-priority task to execute the transactional memory for one time (or submitting and roll-back which consumes more time is selected ) under the two conditions, and is selected from the maximum value of the transactional memory executed by all the tasks having lower priorities than the current task; and because the number of the tasks in the queue is fixed, the worst execution time of the task can be limited in the certain range.
Description
Technical field
The present invention relates to the embedded real-time operating system of computer realm, particularly a kind of a kind of implementation method for embedded real-time operating system software Real-time Transaction internal memory.
Technical background
Embedded real time system refers to have for the task processing time operating system of strict restriction.If the processing time of task surpasses the off period (deadline), may produce serious consequence.Real-time be divided into when strong and soft in real time, in hard real-time system, if overtimely can produce very serious consequence the working time of task, in soft real-time system, then can be influential, but can be very not serious.
Transaction internal memory (Transactional Memory) is a kind of mode that the multitask exclusive reference is shared data in the operating system.In traditional operating system, realize that the method for shared data exclusive reference generally uses spin lock (Spinlock) to guarantee.Under this implementation, a task at first needed to obtain a lock before getting access to shared resource, got access to by other tasks if it detects this lock, so just carried out circular wait, until this lock is released.The shortcoming of this mode is, if there are simultaneously accessing shared datas of a plurality of tasks, their access is that serial is carried out so.Under the relatively fierce environment of data contention, this mode is the comparison poor efficiency.The implementation of transaction internal memory is then different, task can't enter into the critical section and detecting in the past the existence of other tasks, but recorded in the past the state of processor entering the critical section, then when carrying out the critical section or executing the critical section, carry out collision detection.If clash, so just various states (value of register and value of shared data etc.) are returned to and enter into before the critical section, then re-execute, this operation is called rollback.If not conflict so just is written to the content of revising and shares in the data, this operation is called submission.The difference of this mode and spin lock is, when a plurality of task accessing shared data, a plurality of tasks can be carried out the critical section together, are a kind of parallel modes.In competing relatively fiercer environment (namely have a lot of tasks and access simultaneously the critical section), transaction internal memory is compared spin lock larger advantage.The principle of work of transaction internal memory can be with reference to figure 1.The implementation of affairs can be divided into hardware transactional internal memory and software transaction internal memory, and this paper only considers software transaction internal memory, also has, and the method that this paper proposes can realize at uniprocessor, also can realize under the environment of multiprocessor.If realize under the environment of processor, task can only be moved on the processor under it, can not move on other processors.
Transaction internal memory mainly is comprised of two processes: collision detection and management (conflict detection and management) and version management (version management).Whether collision detection is be responsible for to detect in the operation of things internal memory with other things internal memory to clash, conflict management is to be responsible in conflict part with aftertreatment conflict having occured, which if conflict has occured two transaction internal memories, judged by transaction internal memory continuation operation by this part.The operation logic of things internal memory is that upper content with modification is kept in the daily record in fact, share in the data if successfully submitted to so again the content of revising to be write, if clashed and judged by conflict management decision and needed rollback, content in the abort log so, then restore processor environment, perhaps conversely, the shared original content of data is kept in the daily record, in the time of rollback with the content recovery in the daily record to sharing in the data.These all are the parts that version management need to be responsible for.
The above said, in real-time system, the working time of task is overtime may to produce more serious consequence.So usually in the realization of real-time system, must guarantee the predictability of task time.But in the realization of usual transaction internal memory, task may rollback when carrying out the critical section 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 software Real-time Transaction internal memory.
In order to solve the problems of the technologies described above, technical scheme of the present invention is as follows:
The implementation method of software Real-time Transaction internal memory comprises the steps:
11) according to whether can producing conflict between the task, the conflict relationship figure between the generation task, and be several formations according to this conflict relationship figure with all task division, each task belongs to and can only belong to a formation; 12) increased a constant, described constant has been stipulated the maximum rollback number of times of task, if certain task rollback number of times exceeds this constant, then this task is joined in its formation that belongs to and go, tail of the queue in this formation is ranked, and task can enter into dormant state, only has when this task order to head of the queue the time, this task just can be waken up, and then re-executes the code of transaction internal memory;
If in case there are two tasks to clash, then process according to following two kinds of situations:
13) when one of them task be to be arranged in head of the queue, the another one task is not in formation, so at this time just preferentially allow the not task rollback in formation, guarantee that like this task of head of the queue can submit to, when if the number of times of this task rollback has reached the number of times of described constant regulation, its formation that will enter under its is ranked so, and enters into dormant state, wake-up waiting;
14) if two tasks all do not have in formation, priority according to which task is high so, allow the high tasks carrying of priority, the then rollback of another task, if and the rollback number of times that task is arranged has been when having reached the number of times of described constant regulation, this task just joins the formation under its so.
Further, if on a processor, when a low priority task was being carried out the transaction internal memory code, if there is high-priority task to arrive, this high-priority task need to wait for that the transaction internal memory of low priority task is submitted to or rollback just can be seized low priority task afterwards so.
Beneficial effect of the present invention is: according to the method described above, the execution time of task can be divided into four parts: the time of carrying out non-transaction internal memory part, the time of carrying out the transaction internal memory code (comprises the execution time, rollback time and submission time), the blocking time of low priority task and the queuing time in the formation.The time of carrying out non-transaction internal memory part is constant, so fix.Owing to having defined maximum rollback number of times, the time of therefore carrying out the transaction internal memory code can guarantee 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 having dispatched, another kind of situation be occur in task order and be waken up to head of the queue time, but in both cases, the maximum obstruction time all is (or to submit to the time that low priority task is carried out a transaction internal memory, or rollback, get many that consuming time among both), this maximum obstruction time is to elect from the maximal value of all tasks carrying transaction internal memories lower than current task priority.Because task quantity in formation is fixed, so the queuing time of task in formation also fix, and its maximal value is exactly that all belong to other tasks carrying transaction internal memories in this formation and the temporal summation of submission.Therefore, the worst execution time of task also just can limit within the specific limits.
Description of drawings
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 figure;
Fig. 4 is the STM_Start process flow diagram;
Fig. 5 is the STM_Read process flow diagram;
Fig. 6 is the STM_Commit process flow diagram;
Fig. 7 is the STM_Conflict process flow diagram.
Embodiment
The present invention is described further below in conjunction with the drawings and specific embodiments.
In this article, consider just that temporarily a task comprises a transaction internal memory.Namely a transaction internal memory and a task link together.So sometimes may use " task " replacement " transaction internal memory ".Say the transaction internal memory rollback in the task that the task rollback just refers to herein.
TL2 is a kind of relatively more classical transaction internal memory implementation, and it is used in the general operation system.The summary of the invention of this paper is improved a kind of software Real-time Transaction internal memory on the basis of this software transaction internal memory of TL2.Because the realization of this transaction internal memory is comparatively simple, has therefore adopted it as implementation framework, and done some little changes thereon.But the thought of this paper is not limited to this software transaction internal memory.
(1) at first, according to whether producing task conflict graph of a relation of conflict picture between the task.Node among the figure is exactly task, if two tasks may produce conflict, so just these two nodes is drawn a limit.The below provides an example, and is as shown in table 1, if 5 tasks are arranged in the system, and the data access content of task is all as shown in table 1, can draw so the conflict relationship figure between the task, shown in Fig. 2 (a).Can see, because task T1 and T2 have accessed data a1 simultaneously, a2, and all have at least one to be to write when accessing this two variablees, so T1 and T2 have connected a limit.And for variable a3, T1 and T2 read, and T3 writes, so T3 has connected a limit with T1 and T2 respectively.And giving another data structure here to realize software Real-time Transaction internal memory, this data structure is exactly that formation is shown in Fig. 2 (b).Everyly be in that node all is distributed in the same formation in the same UNICOM subgraph, that is to say that every two tasks that are in same formation the inside all might produce conflict.This is a kind of conservative method, just has conflict because only have in the drawings between two continuous nodes, but two nodes in formation might link up by other nodes among the figure, in fact not conflict of these two nodes itself.
The accessed content of table 1 task
| Task | Accessed content |
| T1 | Read a1, read-write a2 reads a3, reads a4 |
| T2 | Write a1, read-write a2 reads a3 |
| T3 | Write a3, write a4 |
| T4 | Read a5 |
| T5 | Write a5 |
(2) constant (MaxAbortNumber) and a formation have been increased.This constant has been stipulated the maximum rollback number of times of task.If certain task rollback after this number of times, it will join in the formation that it belongs to and go so, rank at the tail of the queue of this formation, and task can enter into dormant state.Only have when task order arrives head of the queue, this task just can be waken up by the upper task of being discharged to head of the queue, then re-executes the code of transaction internal memory.If in case there are two tasks to clash, have so following two kinds of situations:
1. one of them task is to be arranged in head of the queue, and the another one task is not in formation.So at this time just preferentially allow the task rollback of head of the queue, because need the maximum rollbacks of assurance task MaxAbortNumber time, the task of head of the queue must be submitted to successfully.The task in formation is not with regard to rollback for another, if the number of times of this task rollback has reached MaxAbortNumber time, this task will enter into its affiliated formation and ranks so, and enters into dormant state, wake-up waiting.
2. if two tasks all do not have in formation, so at this time the conflict management strategy just need to see that the priority of which task is high, allows the high tasks carrying of priority, so relatively meets the demand of real-time system.And if had the rollback number of times of task to reach MaxAbortNumber time, this task would just join its affiliated formation so.
Two tasks that why do not produce conflict all occur in the situation of head of the queue, are because this situation is impossible occur.Because according to the formation division methods that the front was carried, every two tasks that may produce conflict must be in same formation the inside.
(3) also need to consider a problem, in tasks carrying transaction internal memory code, might be seized by high-priority task.If high-priority task has been seized it in certain low priority task operation transaction internal memory code, and two tasks are on the same processor, at this time processor can not be given low priority task, this low priority task can not rollback, high-priority task can not be carried out backward, has so just produced deadlock.For fear of the generation of this situation, the solution of a kind of " delay dispatching " has been proposed.If on a processor, there is a low priority task carrying out the transaction internal memory code, if at this time there is high-priority task to arrive, this high-priority task need to wait for that the transaction internal memory of low priority task is submitted to or rollback just can be seized low priority task afterwards so.Namely the multipotency of high-priority task is blocked time of carrying out a transaction internal memory result of (no matter this time submit to or rollback) by low priority task.
At first, need to consider the metadata (Metadata) of transaction internal memory, they are some Data Structures of realizing software transaction internal memory.Only increased an ObjectHeader on the basis for the metadata of TL2.Each sharing data objects has an ObjectHeader corresponding with it, and transaction internal memory at first will be accessed this ObjectHeader in accessing shared data.As shown in Figure 3, if the first place in first territory of ObjectHeader is 0, illustrate that so it is not locked by other tasks, it all the other are exactly the version number of indication data so, and this version number is used for judging whether data were modified.If 1, illustrate that so these data have been pinned by other tasks, at this time all the other are exactly to point to the task pointer that pins these data.This realize with TL2 in be consistent.Second territory is to point to the pointer of sharing data.The territory of back is visible reader's tabulation (visible reader list), can see having which task reading this shared data from this tabulation the inside.Carried out a numbering for the task of whole system, for each task, just used a bit to represent in visible reader list, corresponding to first bit, task 2 is corresponding to second bit, then by that analogy such as task 1.One 32 variable can represent 32 tasks, and the reason of doing like this is in order to save the space.Why needing increases so territory, is because may produce with other tasks conflict and the rollback of " implicit expression " in the task of head of the queue.Because the data modification of in the time of might other job invocations the head of the queue task being read, the task of head of the queue just needs rollback like this, and this situation is unallowed.So need to know data by which task was read.And had after this visibility list, just do not need to have read daily record, only need to write daily record.
In general, software transaction internal memory has several more common API:STM_Start, STM_Read, STM_Write, STM_Commit, STM_Conflict.
STM_Start calls at first at every section transaction internal memory code, and process flow diagram as shown in Figure 4.At first, if the rollback number of times of task has reached MaxAbortNumber, so just task is joined in the formation corresponding with it, and task enters into sleep state, abdicate processor.If do not reach MaxAbortNumber, with regard to the following normal certain operations that starts of transaction internal memory of just carrying out, such as the save register state, will write the daily record zero clearing so, with state initialization of transaction internal memory etc.
STM_Read and STM_Write are the API that data are shared in read-write in transaction internal memory.Fig. 5 has shown the process of STM_Read, and its input parameter is the pointer of current task and the address that need to read, and rreturn value is the content of reading, and reading in the transaction internal memory operation shared data and all need to be carried out with STM_Read.The STM_Read here and the difference of the STM_Read among the TL2 are, whether still it removed checking current task effective process (whether namely detect the address of reading was modified), because other tasks can be seen the address that current task was read, if produce conflict, that task will be called STM_Conflict and solve conflict when submitting to.Therefore do not need the detection that conflicts here.Here the process flow diagram of STM_Write is not drawn, because its operation is the same with operation among the TL2 basically, except a bit, whether it need to detect current task and be marked as and " abort ", if, it just needs rollback so, if not, so just carried out just according to common operation.Wherein also have an API, STM_Abort namely, its effect is exactly the transaction internal memory of rollback appointed task, and main operation is exactly version number and the content of registers of recovering to share data, and the corresponding positions zero clearing during visible reader tabulated etc.
STM_Commit is the API that submits the transaction internal memory revised context to, and it is an API who calls at the end of transaction internal memory.The process of STM_Commit as shown in Figure 6.Its process more complicated, at first traversal is write daily record (write log), checks to write ObjectHeader corresponding to address that occurs in the daily record, checks at first whether ObjectHeader is locked, if locked, illustrates that other task also writing this address.So at this time just from ObjectHeader, extract the pointer of competition task and call STM_Conflict and solve this conflict.If do not locked, check so in the visible reader tabulation of ObjectHeader whether have the competition task, if having, so just extract respectively the numbering of these tasks out, and call STM_Conflict and solve conflict.Can continue if judge current task, so just iterator be gone back, continue to attempt the lock current task, be recycled to like this competition task always and perceived and abandoned just meeting rollback and this object of release.If the judged result of STM_Conflict is to allow current task continue to carry out, so just attempt the next data object of lock.Note, locking and record the version number before of locking to object is the process of an atomicity.If STM_Conflict judges current transaction internal memory rollback, so just finish.If above-mentioned steps can be passed through, the content that just will write in the daily record writes back to internal memory.Then will write the content release of daily record and enclose new version number, namely revise ObjectHeader corresponding to object.At last, if current transaction internal memory is at head of the queue, so just remove this task from head of the queue, if also have element in the formation, just wake the next element in the formation up, namely new head of the queue element.The consistance of queue operation guarantees with spin lock.
This API of STM_Conflict is an API who processes conflict, namely realizes foregoing conflict management part.As shown in Figure 7, it at first judges whether wherein to have the rollback number of times of a task to reach MaxAbortNumber, if reached, this task is described in formation, so with regard to the transaction internal memory of another task of rollback.If the rollback number of times of two transaction internal memories does not all reach MaxAbortNumber, so just decide which task to continue to carry out according to priority, which rollback, this meets the demand of real-time system, pays the utmost attention to high-priority task.If need rollback competition task, just will compete task flagging here and be " abort ", directly do not call STM_Abort and go rollback competition task.Because whether the competition task all can detect when calling STM_Read or STM_Write is " abort ", if it oneself will rollback so.
According to the method described above, the execution time of task can be divided into four parts: the time of carrying out non-transaction internal memory part, carry out the time (comprising the execution time, rollback time and submission time) of transaction internal memory code, the blocking time of low priority task and the queuing time in the formation.Owing to having defined maximum rollback number of times, the time of therefore carrying out the transaction internal memory code can guarantee 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 having dispatched, another kind of situation be occur in task order and be waken up to head of the queue time, but in both cases, the maximum obstruction time all is the time that low priority task is carried out a transaction internal memory, and this maximum obstruction time is to elect from the maximal value of all tasks carrying transaction internal memories lower than current task priority.Because task quantity in formation is fixed, so the queuing time of task in formation also fix, and its maximal value is exactly the temporal summation of every other tasks carrying transaction internal memory and submission in the formation.Therefore, the worst reaction time of task also just can limit within the specific limits.
The above only is preferred implementation of the present invention; should be pointed out that for those skilled in the art, without departing from the inventive concept of the premise; can also make some improvements and modifications, these improvements and modifications also should be considered as in the protection domain of the present invention.
Claims (2)
1. the implementation method of a software Real-time Transaction internal memory is characterized in that, comprises the steps:
11) according to whether can producing conflict between the task, the conflict relationship figure between the generation task, and be several formations according to this conflict relationship figure with all task division, each task belongs to and can only belong to a formation;
12) increased a constant, described constant has been stipulated the maximum rollback number of times of task, if certain task rollback number of times exceeds this constant, then this task is joined in its formation that belongs to and go, tail of the queue in this formation is ranked, and task can enter into dormant state, only has when this task order to head of the queue the time, this task just can be waken up, and then re-executes the code of transaction internal memory;
If in case there are two tasks to clash, then process according to following two kinds of situations:
13) when one of them task be to be arranged in head of the queue, the another one task is not in formation, so at this time just preferentially allow the not task rollback in formation, guarantee that like this task of head of the queue can submit to, when if the number of times of this task rollback has reached the number of times of described constant regulation, its formation that will enter under its is ranked so, and enters into dormant state, wake-up waiting;
14) if two tasks all do not have in formation, priority according to which task is high so, allow the high tasks carrying of priority, the then rollback of another task, if and the rollback number of times that task is arranged has been when having reached the number of times of described constant regulation, this task just joins the formation under its so.
2. the implementation method of a kind of software Real-time Transaction internal memory according to claim 1, it is characterized in that, if on a processor, when a low priority task is being carried out the transaction internal memory code, if there is high-priority task to arrive, this high-priority task need to wait for that the transaction internal memory of low priority task is submitted to or rollback just can be seized low priority task afterwards so.
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 true CN102929711A (en) | 2013-02-13 |
| CN102929711B 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) |
Cited By (7)
| 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 |
| CN109901913A (en) * | 2017-12-11 | 2019-06-18 | 复旦大学 | A kind of multithreading affairs storage programming model method controllably repeating number |
| CN110275770A (en) * | 2018-03-15 | 2019-09-24 | 阿里巴巴集团控股有限公司 | Task balance dispatching method, system, node and electronic equipment |
| CN110837411A (en) * | 2019-11-08 | 2020-02-25 | 敏博科技(武汉)有限公司 | Internal concurrent I/O scheduling method and system for 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 |
| CN117076145A (en) * | 2023-08-22 | 2023-11-17 | 电子科技大学 | Safe and efficient STM synchronization method based on fine-granularity read-write lock |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2007027365A1 (en) * | 2005-08-30 | 2007-03-08 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
| CN101510162A (en) * | 2009-03-26 | 2009-08-19 | 浙江大学 | 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
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2007027365A1 (en) * | 2005-08-30 | 2007-03-08 | Intel Corporation | Fair scalable reader-writer mutual exclusion |
| CN101510162A (en) * | 2009-03-26 | 2009-08-19 | 浙江大学 | Software transaction internal memory implementing method based on delaying policy |
| US20120005684A1 (en) * | 2010-07-02 | 2012-01-05 | Fiji Systems, Inc. | Priority rollback protocol |
Non-Patent Citations (1)
| Title |
|---|
| 曾坤: "《事务存储系统：事务冲突与事务并行》", 《中国博士学位论文全文数据库 信息科技辑》, no. 7, 15 July 2012 (2012-07-15) * |
Cited By (11)
| 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 |
| CN109901913A (en) * | 2017-12-11 | 2019-06-18 | 复旦大学 | A kind of multithreading affairs storage programming model method controllably repeating number |
| CN109901913B (en) * | 2017-12-11 | 2023-08-22 | 复旦大学 | Multithread transaction storage programming model method capable of controlling repeated execution times |
| CN110275770A (en) * | 2018-03-15 | 2019-09-24 | 阿里巴巴集团控股有限公司 | Task balance dispatching method, system, node and electronic equipment |
| CN110275770B (en) * | 2018-03-15 | 2023-09-22 | 阿里巴巴集团控股有限公司 | Task balanced scheduling method, system, node and electronic equipment |
| CN110837411A (en) * | 2019-11-08 | 2020-02-25 | 敏博科技(武汉)有限公司 | Internal concurrent I/O scheduling method and system for data server side partition |
| 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 |
| CN117076145A (en) * | 2023-08-22 | 2023-11-17 | 电子科技大学 | Safe and efficient STM synchronization method based on fine-granularity read-write lock |
| CN117076145B (en) * | 2023-08-22 | 2024-02-23 | 电子科技大学 | Safe and efficient STM synchronization method based on fine-granularity read-write lock |
Also Published As
| Publication number | Publication date |
|---|---|
| CN102929711B (en) | 2016-08-10 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN102929711A (en) | Implementing method of real-time transactional memory of software | |
| US8775837B2 (en) | System and method for enabling turbo mode in a processor | |
| Rajwar et al. | Transactional lock-free execution of lock-based programs | |
| Rossbach et al. | TxLinux: Using and managing hardware transactional memory in an operating system | |
| Guniguntala et al. | The read-copy-update mechanism for supporting real-time applications on shared-memory multiprocessor systems with Linux | |
| US7962923B2 (en) | System and method for generating a lock-free dual queue | |
| US8689221B2 (en) | Speculative thread execution and asynchronous conflict events | |
| US20100138836A1 (en) | System and Method for Reducing Serialization in Transactional Memory Using Gang Release of Blocked Threads | |
| US20130198749A1 (en) | Speculative thread execution with hardware transactional memory | |
| US20100023732A1 (en) | Optimizing non-preemptible read-copy update for low-power usage by avoiding unnecessary wakeups | |
| CN104487946A (en) | Method, apparatus, and system for adaptive thread scheduling in transactional memory systems | |
| CN1983193A (en) | System and method for processing information | |
| Blake et al. | Proactive transaction scheduling for contention management | |
| CN113205417B (en) | Alliance chain oriented transaction parallel processing method and system | |
| CN101510162B (en) | Software transaction internal memory implementing method based on delaying policy | |
| US20170024249A1 (en) | Parallel Execution Mechanism and Operating Method Thereof | |
| Yodaiken | Against priority inheritance | |
| Keidar et al. | On avoiding spare aborts in transactional memory | |
| CN117112244A (en) | Asymmetric STM synchronization method for mixed real-time task set | |
| Hofmann et al. | Maximum benefit from a minimal HTM | |
| Smolinski | Resolving classical concurrency problems using adaptive conflictless scheduling | |
| CN117076145B (en) | Safe and efficient STM synchronization method based on fine-granularity read-write lock | |
| Lam et al. | The reduced ceiling protocol for concurrency control in real-time databases with mixed transactions | |
| Wu et al. | Real-Time scheduling of CPU-bound and I/O-bound processes | |
| Wan et al. | LockillerTM: Enhancing Performance Lower Bounds in Best-Effort Hardware Transactional Memory |
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 |
Granted publication date: 20160810 |