WO2003001353A2 - Improvements in timer management - Google Patents
Improvements in timer management Download PDFInfo
- Publication number
- WO2003001353A2 WO2003001353A2 PCT/GB2002/002791 GB0202791W WO03001353A2 WO 2003001353 A2 WO2003001353 A2 WO 2003001353A2 GB 0202791 W GB0202791 W GB 0202791W WO 03001353 A2 WO03001353 A2 WO 03001353A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- time
- array
- unidimensional
- timer
- significant
- 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.)
- Ceased
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F1/00—Details not covered by groups G06F3/00 - G06F13/00 and G06F21/00
- G06F1/04—Generating or distributing clock signals or signals derived directly therefrom
- G06F1/14—Time supervision arrangements, e.g. real time clock
Definitions
- This invention relates to improvements in timer management, and in particular to applications where many timers are managed, for example, in telecommunication systems .
- FSM Finite State Machine
- timers are not" an issue when the time period required to manage the timer is significantly less than the time slices available in the environment in which the imers are operating.
- Present systems use timers which are held in a unidimensional array, or a single linked list.
- timers may vary from a few milliseconds to a number of days, and so a timer covering comparatively long periods of time may need allocation in the array/list.
- the process of allocating the timer to a queue of timers depends on the type of array or list being used by the system.
- timers are ordered into a simple queue. Less memory is required for this type of array, however the timer manager has to sort through the array to find a correct allocation. Furthermore, any timer in the array that is positioned behind the newly allocated timer has to be shuffled back to make a space in the array in which the timer is allocated. This shuffling can be very time consuming if there are many timers in the array.
- a telecommunication system might operate over
- a sorted single linked list is comparable to a simple linear array, except that it has a variable size; when a new timer is allocated to the sorted linked list, the list increases in size.
- a pointer in the list points to the entry that is next to expire.
- a binary tree approach might be considered, and works best when the data is random. Timer data is not always random. A binary tress system is likely to be more efficient than the single linked list, however, the binary tree occupies more memory since two links are required for each entry.
- the present invention aims to ameliorate the problems associated with managing a large number of timers, and in its broadest form provides a timer management system that allocates timers in multidimensional array, the position of the timer in the array being determined by the units in the timer.
- a method for setting a timer in a system comprising determining an expiry time value from a timer time value, allocating the expiry time value to a first unidimensional array of a multidimensional array, the multidimensional array having a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, the first unidimensional array corresponding to a first significant unit of the expiry time, and reallocating any remaining significant units of expiry time to another of the plurality of unidimensional arrays when the first significant unit of the expiry time has expired, whereby the timer times out when all significant units of the expiry time have expired.
- a system for setting a timer comprising a multidimensional array, the multidimensional array comprising a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, an expiry time value being determined from the timer value, a first allocator for allocating the expiry time value into a unidimensional array corresponding to a first significant unit of the expiry value, and a second allocator for reallocating any remaining value of the expiry time into any other unidimensional array when the first significant unit of the expiry time has expired, wherein the timer times out when all significant units of the expiry time have expired.
- Embodiments of the present invention have the advantages of reducing the time and memory required for managing timers in systems . The reduction in time spent allocating timers results in systems that are able to handle many more timers without suffering from the problems associated with prior art systems .
- Figure 1 is a representation of a multidimensional array embodying the present invention.
- Figure 2 is a flow diagram of a process embodying the present invention .
- a two dimensional array 10 is split into 3 columns , each column relating to a significant unit of time .
- Column P 12 relates to hours
- column Q 14 relates to minutes
- column R 16 relates to seconds .
- the columns are unidimensional arrays of linked lists , and each column is linked to the next preferably in an hierarchical order .
- Each element in each column relates to a standard unit of time of the significant unit of time that the column represents . For example , there are twenty four elements in the P hours column, sixty elements in the minutes Q column, and sixty elements in the seconds R column; one hour is a standard unit of time in the P column .
- a process 30 for allocating a timer in array 10 is shown .
- the machine , or instantaneous time 32 has discrete significant units of time , A hours , B minutes and C seconds .
- a timer 34 requires allocation in an array (not shown) .
- the timer is set to expire after XX hours , YY minutes and ZZ seconds .
- the instantaneous time and timer values are combined at 36 to calculate a value 39 for an expiry time 38 .
- the timer therefore, expires at A+XX hours, B+YY minutes and C+ZZ seconds .
- the combined system time and timer details 30 are then inserted at 40 into the appropriate element in the array of the most significant unit of the expiry time; in this example, the expiry time is input in the A+XX element in the hour column P 12 in the array 10. So, if the instantaneous time is 00:02:12 and the time being allocated expires after 01:10:03, the A+XX value is equal to 1 and the timer is allocated the 01 element 18 in the array.
- the remaining significant units of the expiry time that is B+YY minutes and C+ZZ seconds 41, are placed in the A+XX element of column P.
- the C+ZZ value 45 is inserted at 44 into the B+YY element of column Q 14. In the example given B+YY is equal to 12 minutes so the C+ZZ remaining value 45 is inserted into the 12 th element of the column Q 20.
- timers can occupy the same element of any column.
- the remaining value for that timer is passed to the next column in the array when the system clock component reaches the element in the array to which that component corresponds .
- clock component we mean the hours, minutes, seconds, etc. of the system clock.
- Other columns for different time values are available, for example, the array may have columns for days, hours, minutes, seconds, milliseconds, and so on.
- b is the number of bytes required for information about each timer
- r is the timer resolution
- the maximum and minimum time to allocate the timer is equal to a, where a is the allocation time
- the sorted array approach is used to store the timers in the order in which they expire. This requires an array which occupies a multiple of the number of timers in the system. So, number of timers in the system;
- the single link list is similar to the sorted array, except that the timer entries are all linked to one another, that is each timer contains information about the location in the array of the next timer to expire .
- the binary tree method is designed to minimise the searching and sorting by putting the timers into a flatter structure and not into a single string. Each entry in this method has at least two branches
- a method embodying the present invention is designed to minimise the time and memory required for allocating, and searching for, the timers.
- the formula used to calculate the memory and time values are as follows :
- e is the initial number of elements in the array at the start of each linked list.
- n is the number of arrays holding the single linked list.
- the values used in these calculations are typical of a real-time telecommunications system
- the results in the table show how the prior art systems are either memory efficient but time consuming, or memory consuming but time efficient.
- the embodiment of the present invention is, in comparison, both memory and time efficient.
- the skilled person will envisage alternatives to the exampled embodiment without leaving the scope of the invention.
- the timer units can be placed in any element of the array corresponding to the value in the timer to that element, with the remainder value being passed to the next appropriate element in the cell when the value expires .
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Data Exchanges In Wide-Area Networks (AREA)
- Measurement Of Unknown Time Intervals (AREA)
- Communication Control (AREA)
Abstract
A method for managing timers in a system reduces the memory and time requirement to allocate and find a timer in an array (10). An expiry time (38) is calculated by combining an instantaneous clock time (32) with the timer time value, and the expiry time (38) is in significant units of time. A multidimensional array (10) comprises a plurality of unidimensional arrays (12, 14, 16). Each unidimensional array (12, 14, 16) corresponds to a significant unit of time and is split into elements. Each element of the unidimensional array (12, 14, 16) corresponds to a standard unit of time for the significant unit of time of that unidimensional array (12, 14, 16). The value of the highest order of significant units of the expiry time (38) is used to determine the position of the timer in the array (10). If any time remains in the expiry time value (39) it is placed with the timer in the array (10). When the expiry time (38) of that significant unit of time has expired, the remaining value is used to determine the position of the timer in the next unidimensional array (12, 14, 16). When no remainder remains in the expiry time value (38), the timer times out.
Description
IMPROVEMENTS IN TIMER MANAGEMENT
This invention relates to improvements in timer management, and in particular to applications where many timers are managed, for example, in telecommunication systems .
Telecommunication standard protocols are often based on Finite State Machine (FSM) systems . FSM systems have time constraints that are most demanding at the device driver level. At this level the protocols are required to cover every instantiation of the FSM. The protocol timers have to be accurate because they are often working with other telecommunication systems that operate their own protocol timers .
The management of timers is not" an issue when the time period required to manage the timer is significantly less than the time slices available in the environment in which the imers are operating. However, in certain applications, it is essential to manage the protocol timers efficiently, especially when many timers are being used. For example, if the time taken to manage an array of timers is excessive, then the timers begin to lose time and a time error is introduced into the system. The error will increase as more and more timers lose time. It is desired to reduce this problem, in particular, in telecommunication applications where a system is often working in conjunction with another telecommunication system. Present systems use timers which are held in a unidimensional array, or a single linked list. As the number of timers increases in these systems, an immense overhead is required for searching through the list to allocate a timer in the correct position and, if necessary, shuffle
other timers in the list to accommodate the timer being allocated. The timers may vary from a few milliseconds to a number of days, and so a timer covering comparatively long periods of time may need allocation in the array/list. The process of allocating the timer to a queue of timers depends on the type of array or list being used by the system.
In a simple linear array a vast amount of memory is needed to cover all timer possibilities . The amount of memory required is proportional to the granularity of the time slices and the range of time that the array needs to cover.
In a sorted array the timers are ordered into a simple queue. Less memory is required for this type of array, however the timer manager has to sort through the array to find a correct allocation. Furthermore, any timer in the array that is positioned behind the newly allocated timer has to be shuffled back to make a space in the array in which the timer is allocated. This shuffling can be very time consuming if there are many timers in the array.
Typically, a telecommunication system might operate over
4,000 timers.
A sorted single linked list is comparable to a simple linear array, except that it has a variable size; when a new timer is allocated to the sorted linked list, the list increases in size. A pointer in the list points to the entry that is next to expire.
A binary tree approach might be considered, and works best when the data is random. Timer data is not always random. A binary tress system is likely to be more efficient than the single linked list, however, the binary tree occupies more memory since two links are required for each entry.
The present invention aims to ameliorate the problems associated with managing a large number of timers, and in its broadest form provides a timer management system that allocates timers in multidimensional array, the position of the timer in the array being determined by the units in the timer.
More specifically, there is provided a method for setting a timer in a system, comprising determining an expiry time value from a timer time value, allocating the expiry time value to a first unidimensional array of a multidimensional array, the multidimensional array having a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, the first unidimensional array corresponding to a first significant unit of the expiry time, and reallocating any remaining significant units of expiry time to another of the plurality of unidimensional arrays when the first significant unit of the expiry time has expired, whereby the timer times out when all significant units of the expiry time have expired.
There is further provided a system for setting a timer comprising a multidimensional array, the multidimensional array comprising a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, an expiry time value being determined from the timer value, a first allocator for allocating the expiry time value into a unidimensional array corresponding to a first significant unit of the expiry value, and a second allocator for reallocating any remaining value of the expiry time into any other unidimensional array when the first significant unit of the expiry time has expired, wherein the timer times out when all significant units of the expiry time have expired.
Embodiments of the present invention have the advantages of reducing the time and memory required for managing timers in systems . The reduction in time spent allocating timers results in systems that are able to handle many more timers without suffering from the problems associated with prior art systems .
An embodiment of the present invention will now be described by way of example and with reference to the figures in which; Figure 1 is a representation of a multidimensional array embodying the present invention; and
Figure 2 is a flow diagram of a process embodying the present invention .
Referring to Figure 1 , a two dimensional array 10 is split into 3 columns , each column relating to a significant unit of time . Column P 12 relates to hours , column Q 14 relates to minutes and column R 16 relates to seconds . The columns are unidimensional arrays of linked lists , and each column is linked to the next preferably in an hierarchical order . Each element in each column relates to a standard unit of time of the significant unit of time that the column represents . For example , there are twenty four elements in the P hours column, sixty elements in the minutes Q column, and sixty elements in the seconds R column; one hour is a standard unit of time in the P column .
Referring to Figure 2 , a process 30 for allocating a timer in array 10 is shown . The machine , or instantaneous time 32 has discrete significant units of time , A hours , B minutes and C seconds . A timer 34 requires allocation in an array (not shown) . The timer is set to expire after XX hours , YY minutes and ZZ seconds .
The instantaneous time and timer values are combined at 36 to calculate a value 39 for an expiry time 38 . The
timer, therefore, expires at A+XX hours, B+YY minutes and C+ZZ seconds .
The combined system time and timer details 30 are then inserted at 40 into the appropriate element in the array of the most significant unit of the expiry time; in this example, the expiry time is input in the A+XX element in the hour column P 12 in the array 10. So, if the instantaneous time is 00:02:12 and the time being allocated expires after 01:10:03, the A+XX value is equal to 1 and the timer is allocated the 01 element 18 in the array.
The remaining significant units of the expiry time, that is B+YY minutes and C+ZZ seconds 41, are placed in the A+XX element of column P. The system clock continues to cycle, and when A+XX=0 at 42, the remaining combined timer values are transferred to the next column in the array. The C+ZZ value 45 is inserted at 44 into the B+YY element of column Q 14. In the example given B+YY is equal to 12 minutes so the C+ZZ remaining value 45 is inserted into the 12th element of the column Q 20.
When the instantaneous clock counts down and B+YY=0, the remainder C+ZZ is transferred 46 to column R in the array. The timer is inserted 48 into the C+ZZ element of column R in the array. The instantaneous clock counts down and when C+ZZ=0 at 50 the timer times out 52 since there are no values remaining in the expiry timer to pass into the next column of the array.
Many timers can occupy the same element of any column. The remaining value for that timer is passed to the next column in the array when the system clock component reaches the element in the array to which that component corresponds . By clock component we mean the hours, minutes, seconds, etc. of the system clock.
Other columns for different time values are available, for example, the array may have columns for days, hours, minutes, seconds, milliseconds, and so on.
If at any time, a value for any significant unit of the expiry time is equal to zero, then that value is ignored and the next significant unit is used to allocate the timer in the relevant array column.
The advantages of the present invention can be shown by calculating typical values for different methods described above. The memory required for the array and the maximum and minimum time require to allocate the timers in the array are illustrated by the following example.
The simple array method is assumed to wrap round at the maximum timer setting M and the memory requirements are calculated using the following formula:
Memory = b (M/r)
where b is the number of bytes required for information about each timer, and r is the timer resolution.
The maximum and minimum time to allocate the timer is equal to a, where a is the allocation time;
Tmax = a Tmin = a
The sorted array approach is used to store the timers in the order in which they expire. This requires an array which occupies a multiple of the number of timers in the system. So, number of timers in the system;
Memory = bt Tmax = a + c(t-l) Tmin = c + a
where fc is the total number of timers in the system, and c is the comparison time.
The single link list is similar to the sorted array, except that the timer entries are all linked to one another, that is each timer contains information about the location in the array of the next timer to expire .
Memory = t (b + s) Tmax = a + c(t - 1)
Tmin = c + a
where s is extra memory required for a single linked list. The binary tree method is designed to minimise the searching and sorting by putting the timers into a flatter structure and not into a single string. Each entry in this method has at least two branches
Memory = t(2s + b) Tmax = c (t - 1 ) + a
Tmin = c + a
A method embodying the present invention is designed to minimise the time and memory required for allocating, and searching for, the timers. In the embodiment described above, the formula used to calculate the memory and time values are as follows :
Memory = t (b + s) + se
where e is the initial number of elements in the array at the start of each linked list.
Tmax = nc + a
Tmin = c + a
where n is the number of arrays holding the single linked list.
By adding the following values to the formulae above, the advantages of the embodiment of the present invention are tangible with respect to the prior art.
Memory
b 5 bytes required to hold information s 3 extra memory for single linked list n 4 number of arrays in present invention e = 256 initial elements
r 10 ms timer resolution m 1 day Maximum timer setting t 4000 total number of timers c 3 ops comparison time a 1 op allocation time
Claims
1. A method for setting a timer in a system, comprising determining an expiry time value from a timer time value, allocating the expiry time value to a first unidimensional array of a multidimensional array, the multidimensional array having a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, the first unidimensional array corresponding to a first significant unit of the expiry time, and reallocating any remaining significant units of expiry time to another of the plurality of unidimensional arrays when the first significant unit of the expiry time has expired, whereby the timer times out when all significant units of the expiry time have expired.
2. A method according to claim 1 , wherein the plurality of unidimensional arrays are arranged in an hierarchical order to form the multidimensional arra .
3. A method according to claim 1 , wherein the expiry time value is determined by combining a timer value with an instantaneous clock value.
4. A method according to claim 1 , 2 or 3 , wherein each unidimensional array comprises a plurality of elements, each element relating to a standard unit of time of the significant unit of time for that unidimensional array.
A method according to any preceding claim, wherein the expiry time is allocated to the element of the unidimensional array which corresponds to the value of the significant unit of the expiry time for that unidimensional array.
A method according to claim 5, wherein the remaining significant units of the expiry time are reallocated to the element .
7. A method according to claim 6 , wherein the remaining significant unit of the expiry time are reallocated to the element of the unidimensional array which corresponds to the value of the remaining standard unit when the first significant unit expires.
8. A method according to claim 7 , whereby when the remaining significant unit of the expiry time comprises a plurality of significant units, the remaining significant units are reallocated to the element of the next unidimensional array in the hierarchical order.
9. A method according to claim 8, wherein the first significant unit of the expiry time is the highest significant unit in the hierarchy of significant units.
10. A method according to any preceding claim, wherein each unidimensional array comprises a linked list.
11. A method according to any preceding claim, wherein the significant units are days, hours, minutes, seconds and milliseconds .
12. A method according to any preceding claim, wherein a plurality of expiry times can occupy the same element of any unidimensional array at the same time.
13. A method according to any preceding claim, wherein the timer is a timer for the system protocols .
14. A method according to any preceding claim, wherein the system is a telecommunications system.
15. A system for setting a timer comprising a multidimensional array, the multidimensional array comprising a plurality of linked unidimensional arrays, each unidimensional array corresponding to a different significant unit of time, an expiry time value being determined from the timer value, a first allocator for allocating the expiry time value into a unidimensional array corresponding to a first significant unit of the expiry value, and a second allocator for reallocating any remaining value of the expiry time into any other unidimensional array when the first significant unit of the expiry time has expired, wherein the timer times out when all significant units of the expiry time have expired.
16. A system according to claim 15, wherein the plurality of unidimensional arrays are arranged in an hierarchical order to form the multidimensional array.
17. A system according to claim 15, wherein the expiry time value is a combination of a timer value with an instantaneous clock value.
18. A system according to claim 15, 16 or 17, wherein each unidimensional array comprises a plurality of elements, each element relating to a standard unit of time of the significant unit of time for that unidimensional array.
19. A system according to any of claims 15 to 18, wherein allocator allocates the expiry time to the element of the unidimensional array which corresponds to the value of the significant unit of the expiry time for that unidimensional array.
20. A system according to any of claims 15 to 19, wherein the significant units are days, hours, minutes, seconds and milliseconds.
21. A system according to any of claims 15 to 20, wherein a plurality of expiry times can occupy the same element of any unidimensional array at the same time.
22. A system according to any of claims 15 to 21, wherein the timer is a timer for the system protocols.
23. A system according to any of claims 15 to 22, wherein the system is a telecommunications system.
24. A system according to any of claims 15 to 23, wherein each unidimensional array comprises a linked list.
Priority Applications (4)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002450030A CA2450030A1 (en) | 2001-06-21 | 2002-06-13 | Improvements in timer management |
| JP2003507680A JP2005506730A (en) | 2001-06-21 | 2002-06-13 | Improvements in timer management |
| EP02730526A EP1454215A2 (en) | 2001-06-21 | 2002-06-13 | Improvements in timer management |
| AU2002302844A AU2002302844A1 (en) | 2001-06-21 | 2002-06-13 | Improvements in timer management |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| GB0115271A GB0115271D0 (en) | 2001-06-21 | 2001-06-21 | Improvements in timer management |
| GB0115271.9 | 2001-06-21 |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| WO2003001353A2 true WO2003001353A2 (en) | 2003-01-03 |
| WO2003001353A3 WO2003001353A3 (en) | 2004-05-21 |
Family
ID=9917139
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| PCT/GB2002/002791 Ceased WO2003001353A2 (en) | 2001-06-21 | 2002-06-13 | Improvements in timer management |
Country Status (6)
| Country | Link |
|---|---|
| EP (1) | EP1454215A2 (en) |
| JP (1) | JP2005506730A (en) |
| AU (1) | AU2002302844A1 (en) |
| CA (1) | CA2450030A1 (en) |
| GB (1) | GB0115271D0 (en) |
| WO (1) | WO2003001353A2 (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7160266B2 (en) | 2000-01-19 | 2007-01-09 | Cordis Neurovascular, Inc. | Inflatable balloon catheter with purge mechanism and method |
| WO2013079097A1 (en) * | 2011-11-29 | 2013-06-06 | Huawei Technologies Co., Ltd. | Delay timer device, method for managing a plurality of delays, and apparatus for delaying a plurality of data packets |
-
2001
- 2001-06-21 GB GB0115271A patent/GB0115271D0/en not_active Ceased
-
2002
- 2002-06-13 EP EP02730526A patent/EP1454215A2/en not_active Withdrawn
- 2002-06-13 WO PCT/GB2002/002791 patent/WO2003001353A2/en not_active Ceased
- 2002-06-13 JP JP2003507680A patent/JP2005506730A/en active Pending
- 2002-06-13 AU AU2002302844A patent/AU2002302844A1/en not_active Abandoned
- 2002-06-13 CA CA002450030A patent/CA2450030A1/en not_active Abandoned
Non-Patent Citations (3)
| Title |
|---|
| R.BROWN: "Calendar queues: a fast 0(1) priority queue implementation for the simulation event set" COMMUNICATIONS OF THE ACM, vol. 31, no. 10, October 1988 (1988-10), pages 1220-1227, XP002272555 * |
| S. BOCKING,V. SEIDEL,P. VINDEBY: "CHANNELS: a run-time system for multimedia protocols " 4TH INTERNATIONAL CONFERENCE ON COMPUTER COMMUNICATIONS AND NETWORKS (ICCCN '95) , 20 - 23 September 1995, pages 178-185, XP002272556 * |
| VARGHESE G ET AL: "HASHED AND HIERARCHICAL TIMING WHEELS: EFFICIENT DATA STRUCTURES FOR IMPLEMENTING A TIMER FACILITY" IEEE / ACM TRANSACTIONS ON NETWORKING, IEEE INC. NEW YORK, US, vol. 5, no. 6, 1 December 1997 (1997-12-01), pages 824-834, XP000734410 ISSN: 1063-6692 * |
Cited By (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7160266B2 (en) | 2000-01-19 | 2007-01-09 | Cordis Neurovascular, Inc. | Inflatable balloon catheter with purge mechanism and method |
| WO2013079097A1 (en) * | 2011-11-29 | 2013-06-06 | Huawei Technologies Co., Ltd. | Delay timer device, method for managing a plurality of delays, and apparatus for delaying a plurality of data packets |
| CN104115457A (en) * | 2011-11-29 | 2014-10-22 | 华为技术有限公司 | Delay timer device, method for managing a plurality of delays, and apparatus for delaying a plurality of data packets |
| US9391904B2 (en) | 2011-11-29 | 2016-07-12 | Huawei Technologies Co., Ltd. | Delay timer device, method for managing a plurality of delays, and apparatus for delaying a plurality of data packets |
| CN104115457B (en) * | 2011-11-29 | 2017-08-25 | 华为技术有限公司 | Delay timing device, method for managing multiple delays, and device for delaying multiple data packets |
Also Published As
| Publication number | Publication date |
|---|---|
| JP2005506730A (en) | 2005-03-03 |
| EP1454215A2 (en) | 2004-09-08 |
| GB0115271D0 (en) | 2001-08-15 |
| CA2450030A1 (en) | 2003-01-03 |
| AU2002302844A1 (en) | 2003-01-08 |
| WO2003001353A3 (en) | 2004-05-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7779413B2 (en) | Method of assigning available resources for internal and external users at start time of scheduled time period based on program reservations information | |
| Seto et al. | Task period selection and schedulability in real-time systems | |
| EP3553657A1 (en) | Method and device for allocating distributed system task | |
| US20050081208A1 (en) | Framework for pluggable schedulers | |
| CN111813513A (en) | Real-time task scheduling method, device, equipment and medium based on distribution | |
| US8769543B2 (en) | System and method for maximizing data processing throughput via application load adaptive scheduling and context switching | |
| GB2194086A (en) | Job scheduling | |
| CN110941602A (en) | Database configuration method and device, electronic equipment and storage medium | |
| Yu et al. | CaaS-LSM: compaction-as-a-service for LSM-based key-value stores in storage disaggregated infrastructure | |
| US6912712B1 (en) | Real time control system for multitasking digital signal processor using ready queue | |
| WO2014046885A2 (en) | Concurrency identification for processing of multistage workflows | |
| EP1396116A1 (en) | Binary-tree method and system for multiplexing scheduling | |
| EP1454215A2 (en) | Improvements in timer management | |
| US7167969B2 (en) | Apparatus and method for writing data to mirrored storage using multiple tasks working in parallel | |
| CN116561171B (en) | Method, device, equipment and medium for processing dual-time-sequence distribution of inclination data | |
| CN112181498A (en) | Concurrency control method, device and equipment | |
| US7930489B2 (en) | Techniques for optimizing configuration partitioning | |
| CN114338694B (en) | One-stop cloud data center server scheduling method and system | |
| US8032543B2 (en) | Sorting apparatus and method | |
| US11461132B2 (en) | Time based priority queue | |
| CN111597392B (en) | Index processing method, device, equipment and storage medium | |
| Jette et al. | Gang scheduler-timesharing the cray t3d | |
| US6829763B1 (en) | Partitioned executive structure for real-time programs | |
| US6724404B1 (en) | Cluster tool reporting system | |
| CN114003178B (en) | Dynamic allocation method and device for log storage partition |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| AK | Designated states |
Kind code of ref document: A2 Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CO CR CU CZ DE DK DM DZ EC EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ OM PH PL PT RO RU SD SE SG SI SK SL TJ TM TN TR TT TZ UA UG US UZ VN YU ZA ZM ZW |
|
| AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZM ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GQ GW ML MR NE SN TD TG |
|
| 121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
| DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
| WWE | Wipo information: entry into national phase |
Ref document number: 2450030 Country of ref document: CA |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 2003507680 Country of ref document: JP |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 028122798 Country of ref document: CN |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 2002730526 Country of ref document: EP |
|
| ENP | Entry into the national phase in: |
Ref document number: 2004106531 Country of ref document: RU Kind code of ref document: A |
|
| ENP | Entry into the national phase in: |
Ref document number: 2004106620 Country of ref document: RU Kind code of ref document: A Ref document number: 2004106784 Country of ref document: RU Kind code of ref document: A |
|
| REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
| WWP | Wipo information: published in national office |
Ref document number: 2002730526 Country of ref document: EP |
|
| WWW | Wipo information: withdrawn in national office |
Ref document number: 2002730526 Country of ref document: EP |