METHOD AND APPARATUS FOR CONTROLLING NETWORK BANDWIDTH

A method of controlling network bandwidth, the method being performed by a server and comprising: receiving a transmission request for data from a client, calculating a delay time for controlling bandwidth of the client, receiving chunks of the data from the client at intervals of the delay time and restoring the data by merging the chunks. A method of controlling network interface, the method being performed by a server and comprising: receiving a reception request for data from a client, calculating a delay time for controlling bandwidth of the client, and sending chunks of the data to the client at intervals of the delay time.

This application claims the benefit of Korean Patent Application No. 10-2015-0151075, filed on Oct. 29, 2015, in the Korean Intellectual Property Office, the disclosure of which is incorporated herein by reference in its entirety.

BACKGROUND

The present inventive concept relates to a method and apparatus for controlling network bandwidth, and more particularly, to a method of controlling a transmission rate of chunks in view of the priority of each piece of data when dividing data into chunks and sending the chunks through a network and an apparatus which performs the method.

2. Description of the Related Art

With the spread of Internet-based solutions such as cloud, network bandwidth is emerging as an issue. However, there is no proper solution to this issue.

In the conventional art, to send data through a network more efficiently, the data is divided into a number of chunks, and the chunks are sent. In some cases, the chunks may be sent in a parallel manner in multiple sessions instead of a single session.

However, due to the absence of an apparatus for controlling network bandwidth, there are cases where one client occupies the entire network bandwidth of a server and where data is sent using the same bandwidth regardless of the priority of data to be sent by each client. This often leads to thoughtless data uploading and downloading without bandwidth management, which results in frequent freezing or locking of a server solution.

There, of course, is a method of controlling network bandwidth using hardware. However, since the hardware is expensive equipment, restriction methods such as port restriction have to be used. In the case of access restriction, in particular, access control itself is difficult, and functions such as quality of service (QoS) cannot be provided.

In this regard, there is a need for a method of controlling network bandwidth using software, the method capable of efficiently solving the problem of network bandwidth in data transmission and securing the stability and reliability of data transmission through QoS management.

SUMMARY

Aspects of the inventive concept provide a method and apparatus for controlling network bandwidth.

However, aspects of the inventive concept are not restricted to the one set forth herein. The above and other aspects of the inventive concept will become more apparent to one of ordinary skill in the art to which the inventive concept pertains by referencing the detailed description of the inventive concept given below.

In some embodiments, a method of controlling network bandwidth, the method being performed by a server and comprising: receiving a transmission request for data from a client, calculating a delay time for controlling bandwidth of the client, receiving chunks of the data from the client at intervals of the delay time, and restoring the data by merging the chunks.

In some embodiments, a method of controlling network interface, the method being performed by a server and comprising: receiving a reception request for data from a client; calculating a delay time for controlling bandwidth of the client, and sending chunks of the data to the client at intervals of the delay time.

In some embodiments, an apparatus for controlling network bandwidth, the apparatus comprising: a network interface, one or more processors, a memory which loads a computer program executed by the processors, and a storage device which stores throughput data and priority information, wherein the computer program executed by the apparatus for controlling network bandwidth comprises: an operation of receiving a transmission request for data from a client, an operation of calculating a delay time for controlling bandwidth of the client, an operation of receiving chunks of the data from the client at intervals of the delay time, and an operation of restoring the data by merging the chunks.

In some embodiments, an apparatus for controlling network bandwidth, the apparatus comprising: a network interface, one or more processors, a memory which loads a computer program executed by the processors, and a storage device which stores throughput data and priority information, wherein the computer program executed by the apparatus for controlling network bandwidth comprises: an operation of receiving a reception request for data from a client, an operation of calculating a delay time for controlling bandwidth of the client, and an operation of sending chunks of the data to the client at intervals of the delay time.

DETAILED DESCRIPTION

FIG. 1illustrates a conventional method of sending data without controlling network bandwidth.

InFIG. 1, a process of sending data from a client100to a server200through a network is illustrated. The client100divides data to be sent into a number of chunks using a data chunker120. In the process of dividing data into a number of chunks, the data chunker120may employ various algorithms. For example, the data chunker120may reduce the amount of data to be sent using data deduplication or may divide data into a number of chunks of the same size simply for parallel data processing. After data is divided into a number of chunks, a send manager110sequentially sends the chunks to the server200. Then, a receive manager210of the server200receives the chunks sent from the send manager110of the client100and sends the received chunks to a data merger220. The data merger220may restore the original data by merging the chunks. That is, the client100may divide data into a number of chunks and send the chunks to the server200, and the server200may obtain the original file by merging the received chunks.

In the conventional art, there are no restrictions between the send manager110of the client100and the receive manager210of the server200. Therefore, the receive manager210of the server200just has to receive chunks sent by the send manager110of the client100. In this case, however, if a particular client100occupies the entire throughput of the server200, other clients cannot access the server200. In addition, since the particular client100occupies system resources of the server200, there are cases where a solution of the server200stops. Furthermore, network bandwidth of the server200is equally shared by clients100regardless of a difference in the importance of the clients100.

This is because data is sent without regard to the fact that the importance of each client100can vary according to the type or size of data to be sent by the client or according to various standards.

FIG. 2illustrates a method of controlling network bandwidth according to an embodiment.

Referring toFIG. 2, a client100additionally includes priority, and a server200additionally includes a throughput manager230and a quality of service (QoS) controller240. The throughput manager230is linked to the receive manager210to measure a transmission rate of each client100and store the measured transmission rate. Therefore, if the maximum throughput of the server200is 10 Mbps, the throughput manager230may manage the sum of the transmission rates of the clients100under 10 Mbps. To this end, the QoS controller240allocates the throughput of the server200to each client100according to priority.

The process of allocating the throughput of the server200to each client100may be implemented by setting a delay time between chunks of data sent by each client100. That is, when sending a number of chunks to the server200, a client100may be controlled to wait for a delay time set by the server200after sending a chunk and before sending a next chunk. In this case, it is possible to prevent a particular client100from occupying the entire throughput of the server200. In addition, if a different delay time is set according to priority, a different throughput value can be set for each client100. Therefore, more important data can be sent first.

To this end, in the method of controlling network bandwidth according to the embodiment, a client100first sends information about chunks to be sent and priority to the server200(operation1), unlike in the conventional art in which the client100sends the chunks directly to the server200. The server200receives the chunk information and the priority and sends to the client100a uniform resource identifier (URI) to which the chunks can be sent and a delay time which is to be used when the chunks are sent using the QoS controller240(operation2). In addition, the server200stores the priority received from the client100in the QoS controller240. This is to compare the priority of the client100with that of another client100when the another client100makes a data transmission request. The URI and the delay time will be described in greater detail later with reference toFIG. 6. The client100receives the URI and the delay time from the server200and sends the chunks to the server200at regular intervals according to the delay time set by the server200(operation3). The server200receives the chunks from the client100and sends the received chunks to a data merger220. Then, the data merger220restores the original data using the chunks. In addition, the server200may send a response indicating the completion of reception of the chunks to the client100(operation4). The responses that can be sent by the server200to the client100may include a reception completion response and a response requesting the client100to resend a chunk if the chunk is defective. Generally, the reception completion response is referred to as an acknowledgement (ACK) response, and the abnormal reception response is referred to as an ASK response.

As illustrated inFIG. 2, the server200can manage the throughput of a client100by setting the delay time of the client100based on chunk information and priority that the client100sent before sending chunks. Therefore, it is possible to prevent a particular client from occupying the entire throughput of the server200. In a case where there are a plurality of clients, a different delay time may be for each of the clients as follows.

FIG. 3illustrates a method of controlling network bandwidth between each client according to an embodiment.

InFIG. 3, unlike inFIG. 2, a plurality of clients, that is, client A100aand client B100bare connected to a server200. Even in this case, the basic data transmission process is not much different fromFIG. 2. However, a QoS controller240of the server200sets a different delay time for each client100aor100baccording to priority sent by the client100aor100band sends the delay time to the client100aor100bso that the client100aor100bhas different throughput. In addition, the server200may not only send the delay time to each client100aor100bin response to chunk information and priority that the client100aor100bsent as advance information before sending chunks, but a throughput manager230of the server200may also measure a data transmission rate of each client100aor100bin real time, and the QoS controller240may change the delay time in real time based on the measured data transmission rate and send the changed delay time to the client100aor100b.

That is, the delay time is a value that is not only set in an initial process of generating a connection but also continuously changed in real time even while the client100aor100bis sending chunks to the server200. Therefore, the throughput manager230of the server200measures and updates the transmission rate of each client100aor100bin real time, and the QoS controller240identifies whether the throughput of the server200has been properly allocated to each client100aor100baccording to priority so that each client100aor100bcan have an appropriate transmission rate and then feeds the adjusted delay time back to each client100aor100bin real time. If the actual transmission rate of each client100aor100bis smaller than the throughput allocated to the client100aor100b, the QoS controller240may change the delay time allocated to the client100aor100bin the initial process of generating a connection to a shorter delay time and feed the shorter delay time back to the client100aor100bas a new set value. On the contrary, if the actual transmission rate of each client100aor100bis greater than the throughput allocated to the client100aor100b, the QoS controller240may feed a delay time longer than the delay time allocated to the client100aor100bin the initial process of generating a connection back to the client100aor100bas a new set value.

Setting a delay time in view of the priority of each client100aor100band changing the delay time in view of the actual transmission rate of each client100aor100bhas been described above. Hereinafter, factors that can be taken into consideration when the server200actually allocates its throughput to each client100aor100bwill be described. First of all, the maximum throughput of the server200may be one criterion that determines the delay time. In addition, the number of clients100currently connected to the server200may be one factor that determines the delay time of each client100. The delay time may also vary according to data priority sent by the client100in the initial process of generating a connection.

FIGS. 4A through 4Fillustrate a delay time in a method of controlling network bandwidth according to an embodiment.

Referring toFIG. 4A, a process in which client A100ahaving a priority of 1 and client B100balso having a priority of 1 send data to a server200having a maximum throughput of 1 is illustrated. Data to be sent by client A100ais composed of four chunks of a unit size of 1. Likewise, data to be sent by client B100bis composed of four chunks of a unit size of 1. First, client A100aand client B100bsend chunk information and priority information to the server200as data transmission requests (operation1). In response to the data transmission requests from client A100aand client B100b, the server200calculates a delay time of each client100aor100band sends the calculated delay time to client A100aor client B100b(operation2). In the example ofFIG. 4A, client A100aand client B100bhave the same conditions. Therefore, a unit time of 1 is set for both client A100aand client B100bas a delay time. Each of client A100aand client B100bnotified of the delay time by the server200controls its throughput by waiting for the delay time after sending one chunk and before sending a next chunk (operation3). After the chunks are completely sent by each of client A100aand client B100b, the server200sends an ACK response to each client100aor100b(operation4). Since the two clients100aand100bhave the same priority, the server200receives data by allocating its throughput equally to the clients100aand100bwithin its maximum throughput. Therefore, it is possible to prevent any one client from occupying the entire throughput of the server200in the example ofFIG. 4A.

Referring toFIG. 4B, unlike in the example ofFIG. 4A, client B100bhas a priority of 2 which is higher than the priority of client A100a. Other conditions are the same as inFIG. 4A, except for the priority of client B100b. In this case, it is necessary to reduce the throughput of client A100aand increase the throughput of client B100ba little. It will hereinafter be assumed that a higher priority value indicates higher priority and greater importance. Since the priority of client B100bis higher than that of client A100a, the throughput of the server100should be allocated a little more to client B100b. To this end, unlike in the example ofFIG. 4A, different delay times should be set for client A100aand client B100b. In this case, since client A100ahas a priority of 1 and client B100bhas a priority of 2, a unit time of 1.5 may be set as a delay time of client A100a, and a unit time of 0.75 may be set as a delay time of client B100b. Accordingly, the throughput of client B100bmay be set to be twice the throughput of client A100a. This is because throughput (i.e., transmission rate) is a value inversely proportional to the delay time. In other words, as the priority of a client increases, the delay time of the client should be set to a smaller value. Until now, of factors that can affect the delay time, priority has been described with reference toFIG. 4B.

Referring toFIG. 4C, unlike in the example ofFIG. 4A, the maximum throughput of the server200has doubled to 2. Other conditions are the same as in the example ofFIG. 4A, except for the maximum throughput of the server200. Since the maximum throughput of the server200has doubled in the example ofFIG. 4Cas compared with the example ofFIG. 4A, the throughput that can be allocated to each client100aor100bmay also double. On the contrary, a delay time set for each client100aor100bis reduced to half. That is, inFIG. 4A, the delay time of each client100aor100bis a unit time of 1 under the same conditions. However, inFIG. 4C, the delay time of each client100aor100bis changed to a unit time of 0.5 under the same conditions except for the maximum throughput of the server200. In other words, even if each client100aor100bsends chunks twice faster than in the example ofFIG. 4A, the server200can process the chunks. Therefore, the maximum throughput of the server200can be utilized efficiently. As the maximum throughput of the server200increases, the delay time decreases in inverse proportion to the maximum throughput. This is because the server200can receive and process more chunks at a time. Until now, of the factors that can affect the delay time, the maximum throughput of the server200has been described with reference toFIG. 4C.

Referring toFIG. 4D, unlike in the example ofFIG. 4A, client C100chas been added. Client C100chas the same priority of 1 as client A100aand client B100b. However, client C100cis different from client A100aand client B100bin that it intends to send seven chunks of a unit size of 1. While the maximum throughput of the server200has been shared by two clients100aand100b, it should now be shared by three clients100athrough100cas a result of the addition of client C100c. Therefore, the clients100athrough100cmay have the same delay time, but the delay time for the clients100athrough100cmay be set to a value greater than the value inFIG. 4A. The QoS controller240of the server200may calculate the delay time and set the delay time of each client100a,100bor100cto a unit time of 1.5. Accordingly, even if a new client100cis added while the existing clients100aand100balready connected to the server200are sending data to the server200, the delay times of the connected clients100aand100bcan be increased, and the throughput of the server200which is secured by increasing the delay times of the connected clients100aand100bcan be allocated to the newly connected client100c. Until now, the number of clients100connected to the server200has been described with reference toFIG. 4Das a factor that can affect the delay time. In the case of a single session based on which the inventive concept has been described above, the delay time is calculated in view of the number of clients100. However, the delay time should be calculated based on the number of sessions connected to the server200in the case of parallel connection such as multiple sessions. In this case, other conditions are the same except that the standard is changed from the number of clients100to the number of sessions. Returning to the case of a single session, as the number of clients100connected to the server200increases, the throughput of the server200which is allocated to each client100is reduced, and a longer delay time is set for each client100. That is, the larger the number of clients100, the longer the delay time.

Referring toFIG. 4E, in the case ofFIG. 4D, client C100chas three more chunks to send than client A100aand client B100b. Therefore, the situation after client A100aand client B100bcomplete chunk transmission will now be described. After receiving all four chunks from each of client A100aand client B100b, the server200restores the original data. Here, the server200may send an ACK response (i.e., a reception completion response) to each of client A100aand client B100b. After receiving the ACK response from the server200, client A100aand client B100bterminate their connection to the server200because they have no more chunks to send. Then, only client C100cremains connected to the server200. Therefore, client C100ccan monopolize the throughput of the server100which was shared with client A100aand client B100b. That is, client C100chad a delay time of 1.5 when sending four chunks, but the delay time of client C100cmay be updated after client A100aand client B100bcomplete chunk transmission. The server200may reduce the delay time of client C100from a unit time of 1.5 to a unit time of 0.5 so that client C100ccan use the throughput previously used by client A100aand client B100b. That is, since the number of clients100connected to the server200which can affect the delay time is a value that can be changed every moment, the QoS controller240of the server200may calculate the delay time of each client100in real time and update the delay time to a new delay time. Accordingly, the throughput of the server200can be shared efficiently regardless of whether the number of clients100connected to the server200is large or small. Until now, of the factors that can affect the delay time, the number of clients100connected to the server200has been described with reference toFIGS. 4D and 4E.

Referring toFIG. 4F, the size of chunks to be sent by client A100ahas doubled compared with the example ofFIG. 4A. That is, while four chunks of a unit size of 1 are sent in the example ofFIG. 4A, two chunks of a unit size of 2 are sent in the example ofFIG. 4F. In most cases, chunks have the same size regardless of client100. However, in some cases, the size of chunks to be sent may vary according to client100. In these cases, the delay time should be calculated in view of the chunk size as well. If a unit time of 1 is set for client A100aas a delay time as in the example ofFIG. 4A, a chunk of a unit size of 2 is sent for a unit time of 1. Therefore, only when the delay time is doubled, can the original throughput allocated to client A100abe secured. In the case ofFIG. 4F, a unit time of 2 which is twice the unit time of 1 inFIG. 4Ais set for client A100aas a delay time. Accordingly, two chunks of a unit size of 2 are sent for a unit time of 4. Therefore, client A100acan secure the same throughput as the throughput of client B100bwhich sends four chunks of a unit size of 1 for a unit time of 4. Until now, of the factors that can affect the delay time, the size of chunks to be sent by a client100has been described with reference toFIG. 4F.

FIG. 5illustrates a method of controlling network bandwidth in a case where a server has no available throughput according to an embodiment.

The method of controlling network bandwidth by setting the delay time of each client100has been described above with reference toFIGS. 4A through 4F. However, even if a server200controls network bandwidth, there may be cases where the server200cannot process data anymore. In this situation, if the server200receives a data transmission request from a client100, it may deal with the data transmission request as inFIG. 5. Referring toFIG. 5, server A200a, server B200b, server C200cand server D200dform one server cluster300. In a situation where server A200acan process no more requests from clients100because it is currently using all its network bandwidth, it may receive a transmission request from client A100a.

In this case, since server A200acannot process the request of client A100a, it may send the request of client A100ato server B200b, server C200cor server D200dwhich can process the request. It would be good if server A200aknew which of server B200b, server C200cand server D200dhad the most available throughput and sent the request to the server with the most available throughput. However, even if server A200adoes not know, if the servers are connected in a circulation structure, it would good enough for server A200ato send the request of client A100ato a next server, i.e., server B200b. If server B200balso cannot process the request of client A100a, it may just send the request of client A100ato server C200c. Likewise, if server C200ccannot process the request of client A100a, it may also send the request of client A100ato server D200d.

When the servers that form the server cluster300are connected in the circulation structure, even if each server does not know the throughput state of other servers, it can find a server which can process a request of a client simply by sending the request to its next server. That is, if the number of servers is n, a server which can process a request of a client can be found after the request is sent (n−1) times in the worst-case scenario. Therefore, when receiving a transmission request from a client100, each server200may identify whether it can process the request of the client100before calculating a delay time. When the server200cannot process the request, it may send the request of the client100to another server. When the server200can process the request, it may calculate the throughput to be allocated to the client100and a delay time corresponding to the throughput and send an URI and the delay time to the client100as a response to the transmission request. This enables load balancing between the servers that form the server cluster300.

FIG. 6is a conceptual diagram illustrating a method of controlling network bandwidth according to an embodiment.

InFIG. 6, a data transmission flow between a client100and a server200can be seen at a glance. For data transmission, the client100divides data to be sent into a number of chunks and sends information about the chunks and priority to the server200as a data transmission request. Here, the information about the chunks consists mainly of the size and number of the chunks. The server200receives the data transmission request of the client100and identifies whether the number of clients connected to the server200has reached a limit. If the number of clients connected to the server200has reached the limit, the server200cannot process the data transmission request of the client100. Therefore, the server200sends an URI of another server to the client100. On the other hand, if the server200can process the data transmission request of the client100, it calculates a delay time to be sent to the client100. Factors that can affect the delay time include priority, the maximum throughput of the server200, the number of clients100connected to the server200, the size of chunks to be sent, etc., as described above with reference toFIGS. 4A through 4F. By taking these factors into consideration, the server200sends the delay time to the client100.

If the server200sends the URI of another server to the client100, the client100should attempt to connect to the server and send a transmission request to the server. On the other hand, if the server200sends its URI and a delay time to the client100, a send manager110of the client100sequentially sends chunks to the server200according to the delay time set by the server200. Then, a receive manager210of the server200receives the chunks from the client100and sends the received chunks to a data merger200to restore the original data from the chunks. The server200measures a chunk transmission rate of the client100in real time and manages the chunk transmission rate using a throughput manager230. A QoS controller240of the server200calculates the delay time of the client100by reflecting, in real time, the transmission rate of the client100managed by the throughput manager230and feeds the delay time back to the client100. If conditions have been changed after the delay time was calculated in the initial process of generating a connection or if the actual throughput of the client100is large or small compared with the initially calculated delay time, the delay time is corrected. In so doing, the throughput of the server200can be utilized efficiently within the maximum throughput of the server200.

FIG. 7is a flowchart illustrating a method of controlling network bandwidth according to an embodiment.

Referring toFIG. 7, a sever200receives, as a data transmission request, information about chunks to be sent and priority from a client100which intends to send data (operation S1000). As described above, the information about the chunks may include the size and number of the chunks to be sent. The server200receives the data transmission request from the client100and identifies whether it can process the data transmission request of the client100by generating an additional connection based on its data processing situation (operation S2000). If the server200cannot process the data transmission request of the client100, it replaces its URI with a URI of another server200(operation52500) and sends the URI of the another server200to the client100(operation S4000). When the client100receives the URI of the another server200instead of the URI of the server200to which the client100sent the data transmission request, it sends the data transmission request to the another server200and proceeds with data transmission according to the situation of the another server200.

If the server200can process the data transmission request of the client100by generating an additional connection, it calculates a delay time to be used when the client100sends the data (operation S3000). As for factors that affect the delay time, the delay time of the client100is set to a smaller value as the priority of the client100is higher. In addition, the delay time is set to a smaller value as the maximum throughput of the server200is greater. The delay time is set to a larger value as the number of clients100connected to the server2000is larger. The delay time is set to a larger value as the size of chunks to be sent by the client100is larger. Through this process, a QoS controller240calculates the delay time in view of the priority sent by each client100together with the data transmission request (operation S3000) and sends the calculated delay time to the client100(operation S4000). The client100sequentially sends the chunks to the server200according to the delay time set by the server200, and the server200sequentially receives the chunks from the client100according to the delay time (operation S5000). In this way, the network bandwidth for the data transmission request of each client100can be controlled efficiently according to priority within the maximum throughput of the server200.

In addition, when the factors that can affect the delay time are changed while the server200is actually receiving chunks from each client100, the server200may calculate a new delay time and feed the new delay time back to each client100. Of the factors that can affect the delay time, the priority of each client100, the maximum throughput of the server200, and the size of chunks to be sent by each client100may be invariable, but the number of clients100connected to the server200may be variable. Therefore, the throughput of each client100may be controlled according to a change in the number of clients100connected to the server200by changing the delay time in real time in view of the variable number of clients100connected to the server200.

In addition to the above-described factors, there are various factors that can actually affect the throughput of each client100. If the above-described factors are controllable factors that can be taken into consideration in the calculation of the delay time, there may also be uncontrollable factors that can affect the throughput of each client100. For example, various factors such as the network state between each client100and the server200and the difference in the performance of the clients100can affect the throughput of each client100. To reduce the effect of these factors on the throughput of each client100, the QoS controller240of the server200may correct the delay time based on a real-time transmission rate of each client100managed by a throughput manager230of the server200. If the actual transmission rate of a client100is smaller than the throughput allocated to the client100, a delay time shorter than a delay time allocated to the client100during initial connection setting may be fed back to the client100as a new set value. On the contrary, if the actual transmission rate of the client100is greater than the throughput allocated to the client100, a delay time longer than the delay time allocated to the client100during the initial connection setting may be fed back to the client100as a new set value.

FIG. 8is a block diagram of an apparatus200for controlling network bandwidth according to an embodiment.

Referring toFIG. 8, the apparatus200for controlling network bandwidth may include a receive manager210, a data merger220, a throughput manager230, and a QoS controller240. The receive manager210may receive a data transmission request and chunks from a client100. The receive manager210may send the data transmission request of the client100to the QoS controller240and request the QoS controller240to determine whether to accept the data transmission request of the client100and, if determining to accept the data transmission request of the client100, calculate a delay time to be used by the client100. In addition, the receive manager210may send the chunks received from the client100to the data merger220to restore the original data from the chunks.

The data merger220receives the chunks of the data from the receive manager210. Although not described in the data transmission process due to its too small size, meta information of each chunk of the data may also be received. Then, the data merger220may identify how the chunks should be merged to obtain the original data and restore the data by merging the chunks.

The throughput manager230is linked in real time to the receive manager210to measure a transmission rate when the server200receives the chunks from the client100. The throughput manager230may provide the measured transmission rate to the QoS controller240so that the QoS controller240can correct the delay time by a difference between the measured transmission rate and the throughput actually allocated to the client100.

When generating an initial connection to the client100, the QoS controller240may determine whether to generate a connection and calculate a delay time to be used by the client100. In addition, when factors that affect the delay time are changed, the QoS controller240may calculate the delay time in real time and feed the delay time back to the client100. Furthermore, when the real-time throughput of each client100which is measured by the throughput manager230is different from the throughput intended to be actually allocated to each client100through delay time setting, the QoS controller240may correct the delay time to reduce the difference and feed the corrected delay time back to the client100.

Until now, a case where data is uploaded from a client100to a server200has mainly been described. However, controlling network bandwidth using a delay time can also be applied to a case where data is downloaded from the client100to the server200. That is, the server200may receive a download request from the client100together with priority and divide data into a number of chunks in order to send the data to the client100. Then, the QoS controller240may calculate a delay time of the client100and sequentially send the chunks to the client100according to the delay time. The only differences from the former case are that there is no need to inform the client100of the delay time because it is the server200that sends the chunks and that the server200can immediately update the delay time for sending data to the client100according to situation. Except for these differences, basic characteristics of controlling network bandwidth using a delay time are the same in the above two cases.

FIG. 9illustrates the hardware configuration of an apparatus200for controlling network bandwidth according to an embodiment.

Referring toFIG. 9, the apparatus200for controlling network bandwidth may include one or more processors510, a memory520, a storage device560, and a network interface570. The processors510, the memory520, the storage device560, and the network interface570may exchange data with each other through a system bus550.

The processors510execute a computer program loaded in the memory520, and the memory520loads the computer program from the storage device560. The computer program may include a receive management operation521, a throughput management operation523, a QoS control operation525, and a chunk merge operation527.

The receive management operation521may receive a data transmission request and chunks from a client100through a network. The receive management operation521may send the data transmission request of the client100to the QoS control operation525and request the QoS control operation525to determine whether to accept the data transmission request and, if determining to accept the data transmission request, calculate a delay time to be used by the client100. Here, the receive management operation521may store priority information565received from the client100in the storage device560through the system bus550. The stored priority information565may be used when the QoS control operation525calculates the delay time of each client100. In addition, chunk data561received from the client100by the receive management operation521may be stored in the storage device560through the system bus550. The receive management operation521may send the chunks stored as the chunk data561in the storage device560to the data merge operation527to restore the original data from the chunks.

The throughput management operation523may be linked in real time to the receive management operation521to measure a transmission rate when the server200receives the chunks from the client100. Then, the throughput management operation523may store the measured transmission rate as throughput data563in the storage device560through the system bus550. The throughput management operation523may provide the stored throughput data563to the QoS control operation525so that the QoS control operation525can correct the delay time by a difference between the measured transmission rate and the throughput actually allocated to the client100.

When generating an initial connection to the client100, the QoS control operation525may determine whether to generate a connection and calculate a delay time to be used by the client100. In addition, when factors that affect the delay time are changed, the QoS control operation525may calculate the delay time in real time and feed the delay time back to the client100. Furthermore, when the real-time throughput of each client100which is measured by the throughput management operation570is different from the throughput intended to be actually allocated to each client100through delay time setting, the QoS control operation525may correct the delay time to reduce the difference and feed the corrected delay time back to the client100.

The data merge operation527receives the chunk data561stored in the storage device560from the receive management operation521through the system bus550. Although not described in the data transmission process due to its too small size, meta information of each chunk of the data may also be received. Then, the data merge operation527may identify how the chunks should be merged to obtain the original data and restore the data by merging the chunks.

According to the inventive concept described above, a session terminal measures the real-time bandwidth of all data being sent and controls the bandwidth of each session in real time based on the measured real-time bandwidth, thereby preventing a particular session from monopolizing network bandwidth.

In addition, QoS is applied to data by managing the bandwidth of both a server and a client. Therefore, data can be sent efficiently according to priority.