KR20010105766A - The method of managing a path reference data structure of the communication switch - Google Patents

Abstract

A combined torque and angular position detector includes two disks (10, 12) rotatable about a common axis. Relative angular displacement of the disks results from torque applied thereto. Each disk has a number of regions of differing optical transmissivity and these control the transmission of optical radiation from a source (20) to an array (22) on which an image of the regions of the disks is formed. A data processor (24) processes image intensity data and determines the angular positions of the disks and their relative displacement. Alternative arrangements are described in which positional information is derived by (i) providing one disk regions of intermediate transmissivity of width varying around one disk, (ii) by having the regions of lesser transmissivity of width varying around one disk or (iii) by arranging combinations of regions of several different widths around one disk.

Description

THE METHOD OF MANAGING A PATH REFERENCE DATA STRUCTURE OF THE COMMUNICATION SWITCH}

The present invention relates to a method of managing a path reference data structure in a communication exchange. In particular, the present invention relates to a method of managing an idle path reference data structure (hereinafter, referred to as a 'path_ref'). The present invention relates to a path_ref management method in a communication exchange that can quickly find and allocate or release path_refs.

In general, a switch of a communication system includes a Path_ref having a structure of path-related variables required for call processing in an ASS (Access Switching Subsystem). The Path_ref has a structure arrangement structure and has 4096.

The Path_ref uses a variable called pref_usg in the structure to determine whether to assign Path_ref, and manages the number of empty Path_ref and the number of Path_ref being used by using variables pref_icnt and pref_acnt in the structure named Path_ent, and pref_ip. Use as an index into Path_ref to start searching.

Referring to the conventional path_ref allocation and release operations with reference to (a) and (b) of FIG. 1, first, in the case of Path_ref allocation, a library block called LSL that manages the allocation and release operations for Path_ref is loaded. Path_ent.pref_ip is set to 0, Path_ent.pref_acnt is set to 0, Path_ent.pref_icnt is set to 4096, and Path_ref [0: 4095] .pref_usg is initialized to u_avl which is unassigned (S1).

After that, when a request for allocation of Path_ref is made (S2), it is determined whether Path_ent.pref_icnt is greater than 0 (S3). If it is not greater than 0, there is no idle Path_ref, and thus FALSE is returned to the library block, indicating that there is no idle Path_ref. (S4).

If Path_ent.pref_icnt is greater than 0, initialize the internal variable i for finding idle Path_ref out of 4096 Path_refs to 0 (S5), and then Path_ref.pref_usg is unassigned with Path_ent.pref_ip indicating the index of Path_ref to start searching. Check whether the state u_avl (S6).

As a result of checking in step S6, if Path_ref.pref_usg is not u_avl, to find an idle Path_ref until u_avl appears, first, Path_ent.pref_ip is increased by 1 (S7), and if this increased Path_ent.pref_ip is greater than 4095 (S8) Set Path_ent.pref_ip to 0 (S9) and then increase the internal variable i by 1 (S10), and if the internal variable i increased in step S10 is less than 4095 (S11) then step S6 If the internal variable i is greater than 4095, return to the library block (S12).

On the other hand, if the path_ent.pref_ip increased in step S7 is less than 4095, the process directly proceeds to step S10 to increase the internal variable I by one, and then repeats the following steps.

As a result of checking in step S6, if Path_ref.pref_usg is u_avl, Path_ent.pref_icnt is decreased by 1, Path_ent.pref_acnt is increased by 1, and Path_ref.pref_usg is set to u_asn by assigning Path_ref, and then Path_ent.pref_ip Increase by 1 (S13).

Subsequently, when the increased Path_ent.pref_ip is greater than 4095 (S14), Path_ent.pref_ip is set to 0 (S15), and true (TRUE) is returned together with the Path_ref number allocated to the library block (S16), and Path_ent.pref_ip If is less than 4095 and proceeds directly to the step (S16).

On the other hand, when releasing Path_ref, when the request for releasing Path_ref comes (S17), the Path_ref number to be released is entered as input, so set Path_ref.pref_usg corresponding to this Path_ref number to u_avl, and decrease Path_ent.pref_acnt by 1 Path_ent.pref_icnt is increased by one (S18).

In this case, since an arc occurs first and is not released first, Path_ref.pref_usg has an irregular value as shown in FIG.

As described above, in order to find an idle Path_ref when allocating and releasing Path_ref, it is necessary to increase the value of Path_ent.pref_ip from 0 to 1 up to 4096. Thus, as shown in FIG. 3, in the worst case, 4096 to find one idle Path_ref. There was a problem to find out.

That is, as shown in FIG. 3, when Path_ent.pref_icnt is 1 (Path_ent.pref_acnt is 4095), one remaining Path_ref should be found. Unfortunately, when one Path_ent.pref_ip is an idle Path_ref number +1 remaining, the worst case is required. We have to look for 4096 to find one idle Path_ref.

As described above, the conventional path_ref management method for managing path_refs by searching for idle path_refs by loops not only decreases the speed of finding the idle path_refs, but also has an inefficient performance capability such as an increase in load due to the increased number of operations. There was a problem.

SUMMARY OF THE INVENTION The present invention has been made to solve the above problems, and its object is to provide a separate arrangement for managing idle Path_ref to quickly find an idle Path_ref and allocate or release Path_ref to increase the speed of finding an idle Path_ref. The purpose of the present invention is to provide a path_ref management method in a communication exchange to reduce the load required for searching.

1 (a) and (b) are flow charts showing the allocation and release operations of a conventional path reference data structure;

2 is a view showing an example after a call progresses to some extent to explain a release operation of a conventional path reference data structure;

3 illustrates an example of a worst case occurring when allocating and freeing a conventional path reference data structure;

4 is a view illustrating initialization of an idle path reference data structure management array and index variables required for performing a path reference data structure management method of the present invention;

5 is a flowchart showing an operation of allocating a path reference data structure according to the path reference data structure management method of the present invention;

6 is a flowchart illustrating a release operation of a path reference data structure according to the path reference data structure management method of the present invention;

7 is a view showing an example of allocation of a path reference data structure by the path reference data structure management method of the present invention;

8 illustrates an example of releasing a path reference data structure by the method of managing a path reference data structure of the present invention.

Path_ref management method in the communication exchange of the present invention for achieving this purpose, idle idle to set the idle Path_ref management array (idle_path_ref) using first_index indicating the first number of the idle Path_ref and last_index indicating the last number. After the Path_ref management array setting step and the idle Path_ref management array setting step, when Path_ref allocation is requested, Path_ref.pref_usg corresponding to idle_path_ref value of first_index is set to u_asn, and the value of first_index is set to-. Path_ref allocation step of setting 1 and after the idle Path_ref management array setting step, when the release of Path_ref is requested, when the value of first_index and last_index is not -1, the idle_path_ref of last_index which is increased is increased. Path_ref which sets number and sets u_avl which is unassigned to Path_ref.pref_usg where Path_ref is released. It characterized by comprising the first step.

Hereinafter, a path_ref management method in a communication exchange according to the present invention will be described in detail with reference to the accompanying drawings.

FIG. 4 is a diagram illustrating initialization of an idle Path_ref management array and an index variable required for performing a Path_ref management method according to the present invention. In the present invention, an array for managing an idle Path_ref, that is, idle_path_ref, is separately set, and is idle in this idle_path_ref. Use first_index for the first number of a Path_ref and last_index for the last number.

A path_ref allocation operation by the path_ref management method of the present invention will be described with reference to the flowchart of FIG. 5.

First, as shown in FIG. 4, the process proceeds to the path_ref allocation request step S22 in the initial state S21 to request Path_ref allocation.

In the initial state 21, first_index indicating the first number of idle Path_refs is initialized to 0 in the idle_path_ref array for managing idle Path_refs, and last_index indicating the last number is respectively initialized to 4095.

When the Path_ref allocation request is received in the Path_ref allocation request step S22, the process proceeds to the first_index value checking step S23 to determine whether the idle_path_ref value corresponding to the current first_index is -1.

After the first_index value checking step (S23), return to the first_index value and set u_asn step (S25). If the idle_path_ref value corresponding to the current first_index is -1 in step S23, the false is returned to the library block so as to idle the path_ref. Notify that there is no (S24).

On the other hand, if the idle_path_ref value corresponding to the current first_index is not -1 in step S23, the idle_path_ref value corresponding to the current first_index is returned to the library block and the corresponding path_ref.pref_usg is set to u_asn. In this case, the value of first_index is set to -1 and left blank (S25).

After the first_index value return and u_asn setting step (S25), the process proceeds to the index comparison step (S26) to determine whether the first_index and the last_index are the same.In this case, if the first_index and the last_index are the same, the process proceeds to the index value setting step (S27) and the first_index and the last_index. Set the value of to -1.

That is, since the first_index and the last_index are equal to each other indicate that there is one currently idle Path_ref, the first_index and last_index are set to -1 to indicate that there is no more idle Path_ref.

If the first_index and the last_index are different, the process proceeds to the index increment step S28 to increase the first_index by 1 so that the next idle Path_ref can be found continuously.

After the index increase step S28, the process proceeds to the index comparison step S29, and if first_index increased in step S28 is greater than 4095, first_index is set to 0 (S30), and if it is less than 4095, checking the value of the first_index. Proceed to (S23) to repeat the following process.

Next, the release operation of Path_ref by the Path_ref management method of the present invention will be described with reference to the flowchart of FIG. 6.

When the Path_ref release request is received in the Path_ref release request step S31, the process proceeds to the Path_ref.pref_usg confirmation step S32 to determine whether Path_ref.pref_usg to release Path_ref is u_asn.

If Path_ref.pref_usg of Path_ref requesting release in the Path_ref.pref_usg confirmation step S32 is not u_asn, the application assumes that Path_ref that is not allocated by the application program is treated as an error (S33).

If Path_ref.pref_usg of Path_ref requesting release in Path_ref.pref_usg confirmation step S32 is u_asn, the process proceeds to index value confirmation step S34 to determine whether the values of first_index and last_index are -1.

If the value of the first_index and the last_index is -1 in the index value checking step S34, the process proceeds to the index value setting step S35 and sets the values of the first_index and the last_index to zero.

That is, since the value of the first_index and the last_index is -1 means that both Path_refs are in use and the first one is released and is in an idle state, so the values of the first_index and the last_index are set to 0.

After the index value setting step S35, the process proceeds to the u_avl setting step S36, sets the number of the requested Path_ref to the idle_path_ref corresponding to the last_index of the step S35, and sets u_avl to the Path_ref.pref_usg from which the Path_ref is released. Set it.

If the value of first_index and last_index is not -1 in the index value checking step S34, the process proceeds to the index increasing step S37 to increase the last_index by one.

After the index increase step S37, the process proceeds to the index comparison step S38. If the last_index increased in the step S37 is greater than 4095, the last_index is set to 0 (S39), and if the last_index is less than 4095, the u_avl setting step In step S36, a path_ref number for which release is requested is set in idle_Path_ref corresponding to the last_index increased in step S37, and u_avl is set in Path_ref.pref_usg in which Path_ref is released.

FIG. 7 is a diagram illustrating an example of allocation of Path_ref by the Path_ref management method of the present invention, and FIG. 8 is a diagram illustrating an example of releasing Path_ref by the Path_ref management method of the present invention. First_index = 4 as shown in FIG. 7. Find the path_ref with the 200 number set in the idle_path_ref and set it to u_asn, and then increase the first_index by 1 to make first_index = 5 so that the idle Path_ref with the 200 number can be found and assigned.

Path_ref release also increases last_index by 1 to make last_index = 1 to last_index = 1, and then sets the number 200 of Path_ref released in idle_path_ref corresponding to last_index = 1, and then id_path_ref released Path_ref. By setting u_avl to the 200 number of, the Path_ref having the 200 number previously assigned can be found and released.

As described above, the present invention provides a separate arrangement for managing idle Path_refs to quickly find an idle Path_ref and allocate or release Path_refs to increase the speed of finding an idle Path_ref and reduce the load required to find it. As a result, more calls can be handled within the ASS, thereby effectively improving the performance of the exchange.

Claims (3)

Setting an idle Path_ref management array setting an idle Path_ref management array (idle_path_ref) using the first numbered index (first_index) and the last numbered index (last_index), and Path_ref allocation step of setting Path_ref.pref_usg corresponding to idle_path_ref value of first_index to u_asn assigned state and setting -1 to the value of first_index when Path_ref allocation is requested after performing the idle Path_ref management array setting step. Wow, After performing the idle Path_ref management array setting step, if the release of Path_ref is requested, the number of the requested Path_ref is set in idle_path_ref of last_index which is increased when the values of first_index and last_index are not -1, and Path_ref is released. A path_ref releasing step of setting an unassigned u_avl in Path_ref.pref_usg. The method of claim 1, wherein the Path_ref allocation step, After initializing the first_index and last_index of the idle_path_ref, if a request for allocation of Path_ref comes, first_index value checking step of checking whether the value of idle_path_ref corresponding to first_index is -1 indicating that there is no idle Path_ref, and the first_index value checking step If the value of idle_path_ref corresponding to first_index is -1, returns a fault to the library block; otherwise, returns the value of first_index that sets Path_ref.pref_usg corresponding to the idle_path_ref value of first_index to u_asn and sets -1 to the value of first_index And after the u_asn setting step, the first_index value return and the u_asn setting step, determine whether the first_index and the last_index are the same, and if the first_index and the last_index are the same, set the values of the first_index and the last_index to -1, and if the first_index and the last_index are different, the first_index is 1; Comparing the index and setting the index value to increase; Management of a path reference data structure in a communication exchange comprising: an index comparison step of setting first_index to 0 if the increased first_index is greater than 4095 in the switch value setting step; Way. The method of claim 1, wherein the Path_ref release step, If a request for releasing Path_ref comes, it determines whether Path_ref.pref_usg to release Path_ref is u_asn, and if Path_ref.pref_usg is not u_asn, if it is u_asn, checks Path_ref.pref_usg to determine whether the value of first_index and last_index is -1. Setting the value of first_index and last_index to 0 if the value of first_index and last_index is -1 in the step of checking the index value, and checking the path_ref.pref_usg and checking the index value, and setting the value of the index to increase the last_index by 1 if not -1 and An u_avl setting step of setting a number of Path_refs required to be released in idle_path_ref of last_index set in the index increasing step, the index value setting and the index increasing step, and setting u_avl in Path_ref.pref_usg from which Path_ref is released; and setting the index value And if the last_index increased in the index increase step is less than 4095, proceed to the u_avl setting step. An index comparison step of setting dex to 0, wherein the path reference data structure is managed in a communication exchange.