115
`United States Patent
`5,774,732
`[45] Date of Patent: Jun. 30, 1998
`Doumard
`
`
`
`[11] Patent Number:
`
`US005 774732A
`
` 56]
`
`[54] DEVICE FOR MANAGING CYCLIC
`POLLINGS FOR THE SUPERVISION OF
`COMPUTER RESOURCES IN A NETWORK
`AND A PROCESS IMPLEMENTED BY SUCH
`A DEVICE
`
`75]
`
`Inventor: Raphaél Doumard, Les Clayes sous
`Bois, France
`
`73] Assignee: Bull S.A., Louveciennes, France
`
`21] Appl. No.: 622,304
`
`22]
`
`30]
`
`Filed:
`
`Mar. 27, 1996
`
`Foreign Application Priority Data
`
`Apr. 6, 1995
`
`[FR]
`
`France oo eeeeeeeesseeeereeeee 95 04093
`
`eeccccccessssssnesssseceusssscecenssseesnse G06F 13/00
`Tint, Cdo
`SL]
`UWS: Gl. sawssnescmmmmemmeemarccnensm 395/727
`52]
`
`58] Field of Search 0... sess 395/727, 289,
`395/200.02, 200.06, 200.11, 200.19, 200.2,
`200.53, 200.55
`
`References Cited
`U.S. PATENT DOCUMENTS
`
`4,638,428
`5,539,882
`5,586,056
`
`1/1987 Gemma etal. cece 395/729
`
`7/1996 Gopaletal. ....
`395/200.1
`12/1996 Watanabe oo... cesses 364/550
`
`FOREIGN PATENT DOCUMENTS
`
`9310495
`
`5/1993 WIPO.
`
`OTHER PUBLICATIONS
`
`Communications for Distributed Applications and Systems,
`ChapelHill, Apr. 18-19, 1991, Conf. 4, Apr. 18, 1991, IEEE,
`pp. 235-242, XP 000278452, J.D. Brock, “Tingle—ASingle
`for Monitoring Networks”.
`
`Primary Examiner—Glenn A. Auve
`Attorney, Agent, or Firm—Kerkam, Stowell, Kondracki &
`Clarke, P.C.; Edward J. Kondracki
`
`[57]
`
`ABSTRACT
`
`A device for managing cyclic pollings for the supervision of
`computer resources in a network, wherein in order to
`execute requests for requesting information requests from
`the various resources in the network using a single operation
`and a single clock, so that each request is emitted with the
`proper frequency, the device includes a data table (DT),
`which is indexed and which contains the data for each
`request to be emitted having its own index (idx) as well as
`its own theoretical emission period (pr), a cyclic poll table
`(PT) which contains the indexes (idx) of the requests with
`the emission dates thereof, which table (PT) is sorted in
`ascending order by the dates, with the first line containing
`the nearest date, and a wait table (WT), indexed by the
`indexes (idx) of the emitted requests waiting for responses,
`which contains the dates (d+pr) of the next emissions. The
`device further implements a process for managing cyclic
`pollings.
`
`5 Claims, 1 Drawing Sheet
`
`Data Table — DT
`
`Wait Table — WT
`
`i
`
`Poll Table — PT
`
`
`
`data,pr
`
`
`
`
`F/
`
`
`
`pi
`
`
`
`
`d+ pr
`
`:
`idx, edl
`
`w+ 003
`
`S
`
`S
`
`Resource
`
`
`
`Google Exhibit 1046
`Google Exhibit 1046
`Google v. Valtrus
`Google v. Valtrus
`
`

`

`U.S. Patent
`
`Jun. 30, 1998
`
`5,774,732
`
`
`
`adin0say
`
`——Oe
`
`zpaGwe.
`
`Ipa‘xp!
`
`Spei
`
`
`
`LM—eI92L410M
`
`
`
`id—21921119d
`
`
`
`ad‘Djop
`
`
`
`10—81901EyDG
`
`|‘Sls
`
`
`
`
`

`

`2
`which is indexed by the indexes idx of the emitted requests
`waiting for responses and which contains the dates d+pr of
`the next emissions. The instant device implements a process
`for managing cyclic pollings which executes, i parallel, a
`first subprocess triggered as soon as a cyclic polling is
`placed in the table PT by a second subprocess, whichfirst
`subprocess empties the table PT,fills the table WT and stops
`when the table PT is empty, while the second subprocess,
`triggered as soon asa responseto the request in progress is
`received, fills the table PT, empties the table WT, and stops
`when there are no further requests waiting for a response.
`Thus, accordingto the instant invention and contraryto all
`expectations, the instant device uses only one operation and
`limits the numberofclocks to a single unit, in spite of highly
`unfavorable preconceptions bythose skilled in the art about
`such a feature. In fact, it
`is generally believed by those
`skilled in the art that it is only possible to limit the number
`of clocks at the price of an extremely high increase in the
`complexity of the managementprocess, whichin principle
`renders this idea completely inapplicable.
`
`BRIEF DESCRIPTION OF THE DRAWING
`
`FIG. 1 a schematic view ofa preferred embodimentof the
`device for managing cyclic pollings in accordance with the
`present invention.
`
`DESCRIPTION OF THE PREFERRED
`EMBODIMENTS
`
`5,774,732
`
`1
`DEVICE FOR MANAGING CYCLIC
`POLLINGS FOR THE SUPERVISION OF
`COMPUTER RESOURCES IN A NETWORK
`AND A PROCESS IMPLEMENTED BY SUCH
`A DEVICE
`
`BACKGROUND OF THE INVENTION
`
`The present invention relates to a device for managing
`cyclic pollings for the supervision of computer resourcesin
`a network.It also relates to a process implemented by this
`device.
`
`10
`
`is desirable to supervise computer
`Generally, when it
`resources in a network, for example in orderto establish or
`verify performances in this network, requests for informa-
`tion are emitted to these resources at regular intervals. Each
`request, known to one skilled in the art as a cyclic polling,
`or “poll”,
`is emitted to a particular resource at regular
`intervals but with its own period, and is specific to a request
`for information characteristic of this particular resource,
`using distinct parameters for this purpose.
`Upto now, two methods have been used to execute these
`requests with a properly determined period. According to the
`first method, an operation, called a “process” by one skilled
`in the art, is created andtriggered to be executed at regular _,.
`intervals delimited by a clock, called a “timer” by one
`skilled in the art, and each operation specific to one resource
`is executed independently from another operation specific to
`another resource. It cannotbe ignored that the choice of such
`a method involves the use of a large number of operations
`or “processes”, which is a major drawback, since it is well
`knownthat one of the problems encountered in computer
`systems is precisely their limitation in numbers of “pro-
`cesses.” A second method, therefore, consists of using a
`single operation which equally and simultaneously controls
`all
`the periods suited to each request, and consequently
`includes a numberof clocks which is equal to the number of
`requests for information and therefore equal to the number
`of resourcesto be supervised, keeping in mind that each time
`a clock runsout, it is automaticallyreset. In use, therefore,
`from a certain number of requests for information, quite a
`significant breakdown in the performanceof a device which
`uses such a method is found, which in this field is a
`prohibitive drawback.
`SUMMARYOF THE INVENTION
`
`15
`
`vwa
`
`30
`
`35)
`
`40
`
`45
`
`With reference to FIG.1, the process for managing cyclic
`pollings implemented bythe device according to the instant
`invention is remarkable in that the first subprocess, once
`triggered, in a first step executes a reading of the date d and
`the index idx present in thefirst line of the table PT and
`erases this first line. In a secondstep, if the table PT is not
`empty, the subprocessinitializes the clock,identifies the date
`d' and the index idx' in the newfirst line of the table PT, and
`appliesa first wake-up function for executing,at the date d',
`this first subprocess for the index idx’. In a third step the
`subprocessreads,in the line of the table DT which has the
`index idx,
`the data related to the information requests
`specific to the request to be emitted on the one hand, and the
`period pr for calculating the date d+pr on the other hand.In
`a fourth step the subprocess authorizes the emission through
`the network of the request related to an identifier id-req
`suited to the request
`to be emitted.
`In a fifth step the
`subprocessadds, to the table WT,a line containingthe index
`idx and the date d+pr, then in a sixth step the subprocess
`applies a second wake-up function for the execution of the
`second subprocess when the response to the requestrelated
`network, which device implements a processusing a single
`to the identifier id-req is received, whichidentifier id-req is
`operation, while makingit possible to easily and efficiently
`retained in the form of parameters. A second subprocessis
`maintain a high performancelevel.
`then triggered in orderto read, in a first step, the date of the
`next cyclic polling in the line of the table WT which has the
`To achieve this object, the device for managing cyclic
`index idx. In a second step the second subprocesserasesthe
`pollings is advantageousin that, in order to execute requests
`line of the table WT which has the index idx, to calculate
`for requesting information from the various resources im the
`from the date d+pr of the next cyclic polling the position at
`network using a single operation and a single clock, so that
`whichto insertthis date in order to keep the table PT sorted.
`each request is emitted with the proper frequency, the device
`includesa first table DT called a data table, which is indexed
`In a fourth step the second subprocessinserts the date d+pr
`and the index idx at the calculated position in the table PT,
`and which contains the data for each request to be emitted
`
`having its own index idx as well as its own theoretical then inafifth step the second subprocess operates to either
`emission period pr. The instant device also includes a second
`cancel the action ofthe first wake-up function applied bythe
`able PT called a cyclic poll
`table, which contains the
`first subprocessif it is still active and to restart the second
`indexes idx of the requests with the emission dates, which
`step of the first subprocess if the calculated position corre-
`able PT is sorted in the ascending order ofthe dates, which
`spondsto thefirst line of the table PT,or to terminate if the
`meansthatthe first line contains the nearest date. The instant
`processing of the information received relative to the
`device further includes a third table WT called a wait table,
`response to the emitted request has been carried out, which
`
`The object of the present invention is to eliminate the
`various drawbacks of the different known methods of the
`prior art, and to provide a device for managing cyclic
`
` pollings for the supervision of computer resources in a 5
`
`wnS
`
`60
`
`65
`
`

`

`5,774,732
`
`3
`first subprocess is activated until the table PT is empty and
`which second subprocess stops when there are no more
`requests waiting.
`Thus, knowing the duration of the period pr after which
`it is necessary to act, and knowingthat the table PT is sorted,
`it 1s possible to knowthe date at which to send the request,
`for example in the form of a function of the GET type. For
`his purpose,
`the index corresponding to the request
`in
`question in the table DT, as well as the date at which to
`elease this request to the network, is placed in the table PT.
`As soonas the request is emitted the line in question in the
`able PT is erased, the corresponding index is placed in the
`able WT, possibly with the useful informationrelated to it
`and, after its calculation, the theoretical time d+pr at which
`his request mustbe re-emitted; however, the responseto this
`equest
`is awaited and no request requesting the same
`information specific to the resource is re-emitted as long as
`his response has not been received. Once the response to
`his request is received, the real date at which this request
`must be re-emitted is calculated and inserted at the correct
`
`position in the table PT,and since this table is always sorted,
`he first element which appears in the first line of the table
`PTis the first element to be emitted.
`
`
`
`10
`
`15
`
`vwa
`
`30
`
`35)
`
`40
`
`45
`
`For a better understanding of the instant invention, the
`following description, which is understood not
`to be 5
`limiting, will make it clear how the invention may be
`implemented.
`With the various computer languages used, and more
`particularly with the languages driven by data or events,
`currently called “event-driven” languages by one skilled in
`the art, a request is emitted through the network with an
`identifier suited to this request;
`it
`is therefore easy to
`distinguish the response to this request by continuing to
`monitor this response at this identifier. It must be noted that
`according to the present invention, the purpose of which to
`use only one operation and one clock, each request must be
`processed independently from another request, and a request
`is suited to an request for information specific to one
`computer resource in the network. This means that two
`identical requests destined for two different resources, even
`if the two resources are identical, are considered to be two
`specific requests, each with its own index andits own period,
`and are therefore processed independently. When the
`response from the network is received, a wake-up function
`activates a restart procedure called a “callback” procedure,
`whichitself contains the operation related to the contents of
`the response, which procedure is therefore associated with
`the reception ofthe result of the request. Thus, for example,
`in the case of a performance supervision service, an action
`wnS
`maybe defined at the reception of a response, such as when 5
`the temperature of a supervised element exceeds a prede-
`termined threshold and an alert is generated. In the same
`way, and simultaneously with the processing of the results
`contained in a response, uponthearrivalof this response,
`the
`next emission of the request in question is calculated andthe
`calculated date is placed in the proper position in the table
`PT. An essential feature is that a request cannot be emitted
`as long as the response to the previous request has not been
`received. However, in a remarkable way, it may be provided
`that if the response to a request has not beenreceived after
`a predetermined time, this request is inhibited and the next
`requestis emitted. It has been statistically noted that such a
`processing is exceptional and is equivalent
`to an error
`control, but in order to avoid a possible deadlock in the
`system, this processing 1s important and necessary.
`In comparison, with the solution of the prior art, in which
`a plurality of clocks is used and eachclockis associated with
`
`
`
`60
`
`65
`
`4
`the
`a request and therefore has an action to carry out,
`the
`requests are emitted at each period whether or not
`responses have been received. Thus, when no response to a
`request has been received,
`this request
`is continually
`re-emitted through the network, needlessly overloading this
`network, and moreover the moreit is re-emitted, the further
`the performances deteriorate.
`However,
`the idea of using only one process and one
`clockis not without problems, and there were serious doubts
`as to the possibility of its application, considering the
`increase in complexity whichthis would entailrelative to the
`management process. Each request to be emitted is, in this
`case, related through a particular context which must make
`it possible to unambiguously determinethe requestitself, the
`emission period and the actions to be carried out when the
`response to this request is received. It is the utilization of
`indexed tables containing the pertinent information which
`authorizes the reconstruction of the appropriate context,
`with each element of the context being read from the index
`in question. The useful information is constituted by two
`parts, a static part which includesthe request, the resources
`for which the information is requested and the period, and a
`dynamic part which is modified at each request
`for
`information, in which the results of the last requests are
`stored,
`for each request and therefore for each index.
`According to the contents of this dynamic part, the actions
`to be carried out, for example in the supervision of perfor-
`mances(alert generation, notification of a change in value,
`etc.), are determined. The processing and switching of the
`requests executed from a single clock involvesa slight time
`loss, since it is necessary to go and seek the useful infor-
`mation in the indexed tables. Thus,each time it is necessary
`to read and determine the index in the table DT in orderto
`
`be able to reposition all the elements, execute the cyclic
`polling, and then modify the new information received by
`restarting. However, not only is this time loss more than
`compensated for, but moreover, performances are signifi-
`cantly improved relative to the device and the processof the
`priorart. In fact, the managementofa plurality of clocksis
`very cumbersome, and the performance of an operation is
`affected considerably and has a tendency to deteriorate
`rapidly. On the other hand, the utilization of the device and
`the process according to the invention shows,
`through a
`simulation of the network,
`that
`there are very minimal
`deviations betweenthe theoretical periodscalculated and the
`actual periods obtained, due to the wait for the responses to
`the requests, which deviations are on the orderof five per
`thousand. Moreover, another advantageis gained relative to
`the device and the process of the prior art, since when it is
`desirable at a given moment to change a period pr,
`the
`algorithm which describes the various steps of the process
`remains unchanged,it is sufficient to modifythis period pr,
`and at the next reading the new period pr’ will be used and
`the calculation of d+pr' will be carried out. On the other
`hand, with a clock which runs continuously, it is necessary
`to stop it in order to modify the period by modifying the
`algorithm, then to re-read all the information loaded and
`finally to restart the clock.
`In fact, in order to significantly reduce the management
`complexity and overcome the preconceived ideas expressed
`in Opposition to the concept behind the present invention,it
`was necessaryto eliminate a certain numberof the system-
`atic steps generating the process to be implemented by
`means of the device claimed herein. Thus, the clock is set
`relative to the first line of the table PT, then when it runs out
`it is restarted for the following line so asto be continuously
`active while the first line is processed, which means that the
`
`

`

`5,774,732
`
`5
`request in question is emitted through the network and that
`simultaneously this first line is erased in the table PT and
`placed in a wait state in the table WT. Theclockis therefore
`systematically reset until the last request. In the very specific
`case of a failure in the network such as a disconnectedline,
`none of the emitted requests receives a response,
`the
`requests are inhibited as the emissions occur, the table PT is
`emptied little by little, and when this table is completely
`empty, the clock is no longer reset and the process stops.
`Returning to the general case, since effectively all of the
`necessary information is in the table DT, from the start the
`algorithm calculates the date of the next request in order to
`place it in the table WT, so that when the response arrives it
`is not necessary to re-read the table DT in order to be able
`to msert the calculated date at the appropriate position in the
`table PT, which thus remains properly sorted.
`The following particular case, whichis extremely simple,
`provides an instructive example which makesit possible to
`gain a clear understanding of the process implemented by
`the device according to the present invention. Suppose that
`asingle, unique requestis to be processed, andthatthe tables
`DT and PTtherefore have only one line, with the table DT
`containing a single index idx,a single period pr and the data
`related to a single request, and with the table PT containing
`a single date d and the index idx. In conformity with the
`present process, the clock is set, and when it is about to run
`out, it is not reset since there is no nextline. Therefore, once
`it runs out, the line in the table PT is erased and, after
`calculation, the date d+pr as well as the index idx are placed
`in the table WT, the request is emitted, and the response
`awaited. When the response received, the operation suited to
`the results is carried out, while the date d+pr and the index
`are placed in the table PT in the appropriate position,thatis,
`the first line, since there is only one line, and therefore the
`clock is again reset.
`Before showing an exampleofthe algorithms which make
`it possible to describe the process used in the present
`invention, various functions or general functionalities
`which, with a few minimal differences, may be found in a
`great many computer languages, will be explained below:
`a function hereinafter called “launchAfter” which wakes
`
`up the process after a determined time t and executes a
`function fet, which function fet and the timet elapsed,
`in the form of parameters,
`a function hereinafter called “removeTimer” which can-
`cels the action of the function “launchAfter” executed
`
`15
`
`25
`
`30
`
`we5
`
`40
`
`45
`
`6
`PollTable[n] indicates the nth line (date d and index idx)
`of the table PT,
`DataTable[idx] or WaitTable[idx] indicates the line of the
`table DT or of the table WT which hasidxas its index,
`WaitTable[end] indicates the last line of the table WT,
`the allocation will be represented by the sign “<—”,
`in addition, when a line of a table is erased, it must be
`understood that the subsequentlines are shifted and the
`numberof lines is decreased byone.
`Oncethese definitionsare set, the first subprocess accord-
`ing to the invention can be described,in this example, by the
`following algorithm 1:
`functionPollOne( )
`start
`
`date_d, idx<PollTable[1]
`erase PollTable[1]
`setTimer( )
`period_pr, datas-DataTable[idx]
`id-req<-sendRequest (data)
`add to WaitTable the line containing the pair (idx,
`period_pr+date_d)
`onReceive(id-req, “insertinPollTable”, idx) end
`Note: the function “insertinPollTable” is described with
`the second subprocess,therefore algorithm 2.
`functionarmTimer( )
`start
`
`if PollTable is not empty
`then
`date_d, idx<PollTable[1]
`launchAfter (date_d-getActualTime, “PollOne”)
`end if
`
`end
`
`When the response to the request is received, the follow-
`ing algorithm 2 is executed:
`functioninsertinPollTable (idx)
`start
`
`dateNextPoll_d<-WaitTable[idx]
`erase WaitTable[idx]
`position<-findPositioninPollTable(dateNextPoll_d)
`insert (dateNextPoll_d,idx) in PollTable[position]
`if position=1
`then
`removeTimer( )
`setTimer( )
`end if
`processResponse( )
`
`end
`Remarkably, the function “insertinPollTable” which rep-
`resents the second subprocess,and therefore the algorithm 2,
`can be used to add new cyclic pollings to be processed in the
`device.
`
`previously. If the function “launchAfter”is not active at
`this instant, no action is carried out,
`a function hereinafter called “sendRequest”, which emits
`a request through the network and supplies a request
`identifier id-req,
`a function hereinafter called “onReceive” which wakes up
`Thus, to summarize the implementation of the process
`the process when the response to a request id-req is
`according to the invention,the first subprocess and conse-
`received and executes a function fet, which function fet
`quently the algorithm 1 is triggered as soon as a requestor
`is passed in parameters in context form,
`“poll” is placed in the table PT during the activation of the
`a function hereinafter called “findPositionPollTable”
`function “insertinPollTable” (second subprocess); it empties
`which takes as its parameters a date and supplies the
`the table PT and fills the table WT and stops as soon as the
`position at which this date must be inserted in orderto
`table PT is empty. The second subprocess and therefore the
`keep the table PT sorted,
`algorithm 2 is triggered as soon as a response to a emitted
`a function hereinafter called “getActualTime” which
`requestis received; it thenfills the table PT, empties the table
`gives the actual date,
`WT,and stops as soon as there are no further responses to
`waiting requests.
`a function hereinafter called “processResponse” which
`The two subprocesses, in fact, work on the same tables, on
`executes the processing of the information received
`the samedata, and in the same wayas with two stacks, with
`during the response to the emitted request.
`
`In addition, the following conventions and notations will one subprocess emptyingafirst “stack,” the table PT, while
`be used:
`the second subprocessfills it and vice versa with the second
`
`0wn
`
`5wn
`
`DpCG
`
`65
`
`

`

`5,774,732
`
`10
`
`15
`
`vwa
`
`30
`
`
`
`7
`the table WT. The two subprocesses are imple-
`“stack”,
`mented in parallel and act almost independently from one
`another, with the table DT beingthe only link between them,
`he first being triggered by the clock and the other by the
`eception of the responses to the requests.
`To conclude,
`the instant device for managing cyclic
`pollings for the supervision of computer resources in the
`network, and the process implemented in conformity with
`he invention, makeit possible, despite a highly unfavorable
`preconception about this idea, to advantageously and easily
`maintain a high level of performance using a single opera-
`ion and a single clock, as just described.
`While the several aspects and embodiments of the inven-
`1on have been illustrated and described,it will be apparent
`0 those of ordinary skill in the art that various changes and
`modifications may be made without deviating from the
`inventive concepts and spirit of the invention, and it is
`intended by the appended claimsto define all such concepts
`which come within the full scope and true spirit of the
`invention.
`I claim:
`
`8
`of the cyclic poll table (PT) anderasingsaidfirst line, means
`for, if the cyclic poll table (PT) is not empty,initializing the
`clock, identifying a date (d') and an index (‘idx’) in a new
`first line of the cyclic poll table (PT) and applying a first
`wake-up function for executing, at the date (d’), said first
`subprocess for the index (idx’), means for reading, in a line
`of the data table (DT) which hasthe index (idx), data related
`to the information requests specific to the request to be
`emitted, and the period (pr) for calculating the date (d+pr),
`meansfor authorizing an emission through the network of
`the request related to an identifier (id-req) associated with
`the request to be emitted, means for adding, to the wait table
`(WT) a line containing the index (idx) and the date (d+pr),
`and means for applying a second wake-up function for an
`execution of the second subprocess when a response to the
`request related to the identifier (id-req) is received, which
`identifier (id-req) is retained in parameters, and further
`wherein the second subprocess triggered includes means for
`reading a date of the next cyclic polling mm a line of the wait
`table (WT) which hasthe index (idx) and erasing the line of
`the wait table (WT) which has the index (idx), means for
`1. Adevice for managing cyclic pollings for the supervi-
`calculating from the date (d+pr) of the next cyclic polling a
`sion of computer resources in a network, wherein, in order
`position at which to insert this date in order to keep the
`to execute requests for requesting information form the
`cyclic poling table (PT) sorted, meansfor inserting the date
`computer resources in the network, the device uses a single
`(d+pr) and the index (idx) at the calculated position in the
`operation and a single clock, so that each request is emitted
`cyclic polling table (PT), meansfor either cancelling thefirst
`with a proper frequency, said device includingafirst data
`wake-up function implemented by thefirst subprocessif the
`table (DT), said data table being indexed and containing data
`first wake-up function1sstill active and restarting in thefirst
`for each request to be emitted having an index (idx) and a
`subprocess said means for initializing,
`identifying and
`theoretical emission period (pr), a second cyclic poll table
`applying if the calculated position correspondsto the first
`(PT) containing indexes (idx) of the requests and emission
`line of the cyclic polling table (PT), or to terminate if the
`dates, which cyclic poll table (PT) is sorted in ascending
`processing of the information received relative to the
`orderby the emission dates, whereina first line of said cyclic
`response to the emitted request has been carried out, and
`poll table (PT) contains a nearest emission date, and a third
`further including meansfor enabling said fist subprocess to
`wait table (WT) indexed by the indexes (idx) of emitted
`be activated until the cyclic polling table (PT) is empty and
`requests waiting for responses and which contains the dates
`stopping said second subprocess when there are no more
`(d+pr) of a next emissions, said device further including
`requests waiting.
`means for implementing a process for managing cyclic
`3. The device for managing cyclic pollings according to
`pollings and executing, in parallel, a first subprocess trig-
`claim 2, wherein said device includes meansfor inhibiting
`gered as soon as a cyclic polling is placed in the cyclic poll
`said request if the response to a requestis not received after
`table (PT) by a second subprocess, which first subprocess
`a predetermined time.
`FSP empties the cyclic poll table (PT), fills the wait table
`4. The device for managing cyclic pollings according to
`(WT) and stops when the cyclic poll table (PT) is empty,
`claim 3, wherein the second subprocess includes means for
`while the second subprocess SSP, triggered as soon as a
`adding new cyclic pollings to be processed.
`response to the request in progress 1s received,fills the cyclic
`5. The device for managing cyclic pollings according to
`poll table (PT), empties the wait table (WT) and stops when
`claim 2, wherein the second subprocess includes means for
`there is no further request waiting for a response.
`adding new cyclic pollings to be processed.
`2. The device for managing cyclic pollings according to
`claim 1, wherein the first subprocess includes means for
`reading a date (d) and the index (idx) presentin thefirst line
`
`35)
`
`40
`
`45
`
`