Method and system for generating conditional alarm in a network

Abstract

The present disclosure provides a system (108) and a method (400) for generating a conditional alarm in a network (106). The method (400) includes requesting one or more objects to be borrowed from an object pool. The method (400) further includes maintaining a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The method (400) further includes storing the counter value corresponding to each of one or more borrowed objects in a database (210). The method (400) further includes calculating an average count of the one or more borrowed objects based on the stored counter value. The method (400) further includes comparing the calculated average count with a preconfigured value. Further, the method (400) includes generating the conditional alarm if the calculated average count exceeds the preconfigured value.

Description

METHOD AND SYSTEM FOR GENERATING CONDITIONAL ALARM IN A NETWORKRESERVATION OF RIGHTS

[0001] A portion of the disclosure of this patent document contains material, which is subject to intellectual property rights such as, but are not limited to, copyright, design, trademark, Integrated Circuit (IC) layout design, and / or trade dress protection, belonging to Jio Platforms Limited (JPL) or its affiliates (hereinafter referred as owner). The owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent files or records but otherwise reserves all rights whatsoever. All rights to such intellectual property are fully reserved by the owner.TECHNICAL FIELD

[0002] The present disclosure relates generally to the field of telecommunication networks. The present disclosure relates to a system and a method for generating a conditional alarm in a network to manage overload conditions.DEFINITIONS

[0003] As used in the present disclosure, the following terms are generally intended to have the meaning as set forth below, except to the extent that the context in which they are used indicates otherwise.

[0004] The term ‘network function’ as used herein refers to an entity within a telecommunication network that performs specific network operations, such as handling call flows, managing network resources, and maintaining communication protocols. The different types of network functions may include a Policy Control Function (PCF), a Binding Support Function (BSF), a Charging Function (CHF), a Network Repository Function (NRF), and the like.

[0005] The term ‘PCF’ as used herein refers to the Policy Control Function responsible for providing policy rules to control user plane behavior, such as Quality of Service (QoS), traffic routing, and access control.

[0006] The term ‘BSF’ as used herein refers to the Binding Support Function in a network that supports binding of user sessions to specific policy and charging rules.

[0007] The term ‘CHF’ as used herein refers to the Charging Function in the network responsible for charging-related activities, including collecting charging data and interfacing with billing systems.

[0008] The term ‘NRF’ as used herein refers to the Network Repository Function in the network that maintains a repository of available network function and their capabilities.

[0009] The term ‘objects’ as used herein refers to resources like threads, database connections, or other computational resources that the network function needs to perform its tasks. These resources are pre-created and stored in an object pool to be readily available when needed.

[0010] The term ‘object pool’ as used herein refers to a storage where a collection of pre-initialized objects (e.g., threads, database connections) is maintained. The objects are readily available for use, allowing the network function to borrow and return them as needed, thereby improving resource management and system performance.

[0011] The term ‘borrowed object’ as used herein refers to an instance of a resource that has been temporarily taken from the object pool by the network function to perform a specific task. Once the task is completed, the borrowed object is returned to the pool for reuse by other processes.

[0012] The term ‘counter’ as used herein refers to a variable used to keep track of a number of specific events or instances, such as the number of objects currently borrowed from the object pool.

[0013] The term ‘threshold value breach’ as used herein refers to a condition where the average count of borrowed objects exceeds a predefined limit. The threshold value breach indicates a potential overload or abnormal behavior in the system, which may trigger a conditional alarm for further investigation.

[0014] The term ‘Fault, Configuration, Accounting, Performance, and Security management (FCAPS) module’ as used herein, refers to a microservice used in network management that provides a comprehensive approach for managing and monitoring a health, configuration, usage, performance, and security of various network resources.

[0015] The term ‘overload condition’ as used herein refers to a situation in which the demand for resources (such as objects within a pool) in the network function exceeds the predefined threshold limits. The overload condition arises when the system experiences a sudden or sustained increase in resource utilization, leading to potential inefficiencies, slowdowns, or failures in network operations.

[0016] The term ‘conditional alarm’ as used herein refers to an alarm that is triggered only when specific conditions are met. For example, the conditional alarm is raised when both (e.g., the counter value and the average count value) exceed their respective predefined threshold values, ensuring that the alarm is not triggered by a single transient event but rather by a consistent issue that meets the defined conditions.

[0017] These definitions are in addition to those expressed in the art.BACKGROUND

[0018] The following description of related art is intended to provide background information pertaining to the field of the disclosure. This section may include certain aspects of the art that may be related to various features of the present disclosure.However, it should be appreciated that this section be used only to enhance the understanding of the reader with respect to the present disclosure, and not as admissions of prior art.

[0019] Wireless communication technology has rapidly evolved over the past few decades, with each generation bringing significant improvements and advancements. The first generation of wireless communication technology was based on analog technology and offered only voice services. However, with the advent of the second- generation (2G) technology, digital communication and data services became possible, and text messaging was introduced. The third generation (3G) technology marked the introduction of high-speed internet access, mobile video calling, and location-based services. The fourth generation (4G) technology revolutionized wireless communication with faster data speeds, better network coverage, and improved security. Currently, a fifth-generation (5G) technology is being deployed, promising even faster data speeds, low latency, and the ability to connect multiple devices simultaneously. With each generation, wireless communication technology has become more advanced, sophisticated, and capable of delivering more services to its users.

[0020] In modern telecommunications environments, resource pooling and management have become integral components of scalable network operations. The telecommunication systems often rely on shared resource pools, commonly referred to as “object pools,” which allow for efficient allocation, reuse, and monitoring of system resources such as memory, processes, or service instances. Object pools improve resource efficiency and performance by minimizing overhead in high-load conditions. However, these resource-sharing mechanisms are also critical points of failure if not managed proactively, especially in large-scale systems where load dynamics fluctuate rapidly.

[0021] A significant challenge in telecommunication systems lies in the effective monitoring of the object pools to detect conditions of resource exhaustion orperformance bottlenecks. In conventional systems, alarms or alerts related to object pool utilization are typically generated only when a static threshold is breached. The threshold-based alarms are often too reactive, lacking context-sensitive intelligence or dynamic configurability. As a result, operators are frequently notified only after a critical condition has already occurred, leaving minimal response time to avert service degradation or failures.

[0022] Existing solutions do not offer a flexible framework for defining conditions under which alarms should be triggered based on object pool status. The telecommunication systems fail to incorporate contextual factors such as network function application’s operational state, type of object pool in use, or real-time resource consumption trends. Consequently, they generate false positives or miss critical alerts entirely, reducing operational efficiency and increasing the risk of service-level agreement (SLA) violations.

[0023] Furthermore, the inability to configure object pool alarms dynamically across varied usage scenarios leads to under-optimized performance of the network. The absence of conditionally intelligent alarm mechanisms restricts proactive resource management and limits the adaptability of infrastructure to real-time operational demands.

[0024] There is, therefore, a need for a system and a method that overcomes the limitations of the prior art.SUMMARY OF THE DISCLOSURE

[0025] In an exemplary embodiment, a method for generating a conditional alarm in a network is described. The method includes requesting one or more objects to be borrowed from an object pool. The method further includes maintaining a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The method includes storing the counter value corresponding to each of one or more borrowed objects in a database. Further, the method includescalculating an average count of the one or more borrowed objects based on the stored counter value. The method further includes comparing the calculated average count with a preconfigured value. Further, the method includes generating the conditional alarm if the calculated average count exceeds the preconfigured value.

[0026] In an embodiment, the counter value corresponding to each object is stored in the database as a list and is updated at a regular time period.

[0027] In an embodiment, the average count is calculated by dividing a sum of the counter value stored as the list by a number of selected entries from the list in the database.

[0028] In an embodiment, the one or more borrowed objects include at least one of a thread, a database connection, a network socket, and a memory buffer.

[0029] In an embodiment, the method further includes periodically checking whether the calculated average count associated with the object pool exceeds the preconfigured value. The preconfigured value indicates a permissible limit for the one or more objects borrowed from the object pool.

[0030] In an embodiment, the generated conditional alarm indicates an occurrence of at least one overload condition in the network.

[0031] In an embodiment, the method further includes displaying the generated conditional alarm and the list on a user interface (UI) to notify a user.

[0032] In an embodiment, the method further includes configuring the object pool with a set of parameters to manage a borrowing of the one or more objects. The set of parameters includes a maxActive parameter indicating a maximum number of active objects that are available to be borrowed from the object pool, a maxldle indicating a maximum number of idle objects present in the object pool, and a maxWait parameter indicating a maximum number of objects waiting to be borrowed.

[0033] In an embodiment, the method further includes defining a threshold for each object in the object pool. The threshold represents a maximum number of borrowing of the object from the object pool.

[0034] In an embodiment, the at least one operation includes one of incrementing the counter value corresponding to an object upon borrowing the object from the object pool and decrementing the counter value corresponding to the object upon returning a borrowed object to the object pool.

[0035] In another embodiment, a system for generating a conditional alarm in a network is described. The system includes a network function configured to request one or more objects to be borrowed from an object pool. The network function further includes a memory configured to store the one or more borrowed objects. The network function further includes a processing engine coupled to the memory. The processing engine is configured to receive the one or more borrowed objects from the memory and execute instructions stored in the memory to maintain a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The processing engine is further configured to execute instructions stored in the memory to store the counter value corresponding to each of one or more borrowed objects in a database. Further, the processing engine is configured to execute instructions stored in the memory to calculate an average count of the one or more borrowed objects based on the stored counter value. The processing engine is further configured to execute instructions stored in the memory to compare the calculated average count with a preconfigured value. Further, the processing engine is configured to execute instructions stored in the memory to generate the conditional alarm if the calculated average count exceeds the preconfigured value.

[0036] In yet another embodiment, a computer program product including a non- transitory computer-readable medium including instructions that, when executed by one or more processors, cause the one or more processors to perform a method for generating a conditional alarm in a network. The method includes requesting one ormore objects to be borrowed from an object pool. The method further includes maintaining a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The method includes storing the counter value corresponding to each of one or more borrowed objects in a database. Further, the method includes calculating an average count of the one or more borrowed objects based on the stored counter value. The method further includes comparing the calculated average count with a preconfigured value. Further, the method includes generating the conditional alarm if the calculated average count exceeds the preconfigured value.OBJECTIVES OF THE PRESENT DISCLOSURE

[0037] Some of the objectives of the present disclosure, which at least one embodiment herein satisfies, are as follows:

[0038] An objective of the present disclosure is to provide a system and a method for generating a conditional alarm in a network to manage overload conditions in network functions.

[0039] Another objective of the present disclosure is to monitor one or more objects being borrowed from an object pool by at least one network function.

[0040] Another objective of the present disclosure is to calculate an average count of the one or more borrowed objects over a predefined time period to detect the overload condition.

[0041] Another objective of the present disclosure is to raise an alarm (e.g., a conditional alarm) when the average count is breached, ensuring that only a true overload condition raises the alarm.

[0042] Another objective of the present disclosure is to prevent a false alarm by distinguishing between transient spikes and sustained overload conditions in the at least one network function.

[0043] Another objective of the present disclosure is to optimize resource management within the at least one network function by providing insights into borrowing patterns and resource utilization.

[0044] Other objectives and advantages of the present disclosure will be more apparent from the following description, which is not intended to limit the scope of the present disclosure.BRIEF DESCRIPTION OF THE ACCOMPANYING DRAWING

[0045] The accompanying drawings, which are incorporated herein, and constitute a part of this disclosure, illustrate exemplary embodiments of the disclosed methods and systems in which like reference numerals, refer to the same parts throughout the different drawings. Components in the drawings are not necessarily to scale; emphasis is instead being placed upon clearly illustrating the principles of the present disclosure. Some drawings may indicate the components using block diagrams and may not represent the internal circuitry of each component. It will be appreciated by those skilled in the art that disclosure of such drawings includes disclosure of electrical components, electronic components, or circuitry commonly used to implement such components.

[0046] FIG. 1 illustrates an exemplary network architecture of a system for generating a conditional alarm in a network, in accordance with an embodiment of the present disclosure.

[0047] FIG. 2 illustrates a block diagram of an exemplary system for generating the conditional alarm in the network, in accordance with an embodiment of the present disclosure.

[0048] FIG. 3A illustrates an exemplary flow diagram of a method for generating the conditional alarm in the network, in accordance with an embodiment of the present disclosure.

[0049] FIG. 3B illustrates another exemplary flow diagram of a method for generating the conditional alarm in the network, in accordance with an embodiment of the present disclosure.

[0050] FIG. 4 illustrates a flow diagram of a method for generating the conditional alarm in the network, in accordance with an embodiment of the present disclosure.

[0051] FIG. 5 illustrates an example computer system in which or with which the embodiments of the present disclosure may be implemented.

[0052] The foregoing shall be more apparent from the following more detailed description of the disclosure.LIST OF REFERENCE NUMERALS100 - Network architecture102 - User(s)104 - User Equipment (UE)106 - Network108 - System200 - Block diagram202 - Processor(s)204 - Memory206 - Interface(s)208 - Processing engine210 - Database212 - Requesting unit214 - Maintaining unit216 - Storing unit218 - Calculating unit220 - Comparing unit222 - Generating unit300 A, 300B - Flow Diagram400 - Method500 - Computer System510 - External Storage Device520 - Bus530 - Main Memory540 - Read Only Memory550 - Mass Storage Device560 - Communication Port570 - ProcessorDETAILED DESCRIPTION

[0053] In the following description, for the purposes of explanation, various specific details are set forth in order to provide a thorough understanding of embodiments of the present disclosure. It will be apparent, however, that embodimentsof the present disclosure may be practiced without these specific details. Several features described hereafter can each be used independently of one another or with any combination of other features. An individual feature may not address any of the problems discussed above or might address only some of the problems discussed above. Some of the problems discussed above might not be fully addressed by any of the features described herein. Example embodiments of the present disclosure are described below, as illustrated in various drawings in which like reference numerals refer to the same parts throughout the different drawings.

[0054] The ensuing description provides exemplary embodiments only, and is not intended to limit the scope, applicability, or configuration of the disclosure. Rather, the ensuing description of the exemplary embodiments will provide those skilled in the art with an enabling description for implementing an exemplary embodiment. It should be understood that various changes may be made in the function and arrangement of elements without departing from the spirit and scope of the disclosure as set forth.

[0055] Specific details are given in the following description to provide a thorough understanding of the embodiments. However, it will be understood by one of ordinary skill in the art that the embodiments may be practiced without these specific details. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form in order not to obscure the embodiments in unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail in order to avoid obscuring the embodiments.

[0056] Also, it is noted that individual embodiments may be described as a process that is depicted as a flowchart, a flow diagram, a data flow diagram, a structure diagram, or a block diagram. Although a flowchart may describe the operations as a sequential process, many of the operations can be performed in parallel or concurrently. In addition, the order of the operations may be re-arranged. A process is terminated when its operations are completed but could have additional steps not included in afigure. A process may correspond to a method, a function, a procedure, a subroutine, a subprogram, etc. When a process corresponds to a function, its termination can correspond to a return of the function to the calling function or the main function.

[0057] The word “exemplary” and / or “demonstrative” is used herein to mean serving as an example, instance, or illustration. For the avoidance of doubt, the subject matter disclosed herein is not limited by such examples. In addition, any aspect or design described herein as “exemplary” and / or “demonstrative” is not necessarily to be construed as preferred or advantageous over other aspects or designs, nor is it meant to preclude equivalent exemplary structures and techniques known to those of ordinary skill in the art. Furthermore, to the extent that the terms “includes,” “has,” “contains,” and other similar words are used in either the detailed description or the claims, such terms are intended to be inclusive like the term “comprising” as an open transition word without precluding any additional or other elements.

[0058] Reference throughout this specification to “one embodiment” or “an embodiment” or “an instance” or “one instance” means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment of the present disclosure. Thus, the appearances of the phrases “in one embodiment” or “in an embodiment” in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.

[0059] The terminology used herein is to describe particular embodiments only and is not intended to be limiting the disclosure. As used herein, the singular forms “a”, “an”, and “the” are intended to include the plural forms as well, unless the context indicates otherwise. It will be further understood that the terms “comprises” and / or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and / or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements,components, and / or groups thereof. As used herein, the term “and / or” includes any combinations of one or more of the associated listed items. It should be noted that the terms “mobile device”, “user equipment”, “user device”, “communication device”, “device” and similar terms are used interchangeably for the purpose of describing the invention. These terms are not intended to limit the scope of the invention or imply any specific functionality or limitations on the described embodiments. The use of these terms is solely for convenience and clarity of description. The invention is not limited to any particular type of device or equipment, and it should be understood that other equivalent terms or variations thereof may be used interchangeably without departing from the scope of the invention as defined herein.

[0060] As used herein, an “electronic device”, or “portable electronic device”, or “user device” or “communication device” or “user equipment” or “device” refers to any electrical, electronic, electromechanical, and computing device. The user device is capable of receiving and / or transmitting one or parameters, performing function / s, communicating with other user devices, and transmitting data to the other user devices. The user equipment may have a processor, a display, a memory, a battery, and an inputmeans such as a hard keypad and / or a soft keypad. The user equipment may be capable of operating on any radio access technology including but not limited to IP-enabled communication, Zig Bee, Bluetooth, Bluetooth Low Energy, Near Field Communication, Z-Wave, Wi-Fi, Wi-Fi direct, etc. For instance, the user equipment may include, but not limited to, a mobile phone, smartphone, virtual reality (VR) devices, augmented reality (AR) devices, laptop, a general-purpose computer, desktop, personal digital assistant, tablet computer, mainframe computer, or any other device as may be obvious to a person skilled in the art for implementation of the features of the present disclosure.

[0061] Further, the user device may also comprise a “processor” or “processing unit” includes processing unit, wherein processor refers to any logic circuitry for processing instructions. The processor may be a general-purpose processor, a specialpurpose processor, a conventional processor, a digital signal processor, a plurality of microprocessors, one or more microprocessors in association with a DSP core, a controller, a microcontroller, Application Specific Integrated Circuits, Field Programmable Gate Array circuits, any other type of integrated circuits, etc. The processor may perform signal coding data processing, input / output processing, and / or any other functionality that enables the working of the system according to the present disclosure. More specifically, the processor is a hardware processor.

[0062] While considerable emphasis has been placed herein on the components and component parts of the preferred embodiments, it will be appreciated that many embodiments can be made and that many changes can be made in the preferred embodiments without departing from the principles of the disclosure. These and other changes in the preferred embodiment, as well as other embodiments of the disclosure, will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the disclosure and not as a limitation.

[0063] Wireless communication technology has rapidly evolved over the past few decades. The first generation of wireless communication technology was analog, offering only voice services. Further, text messaging and data services became possible when the second-generation (2G) technology was introduced. The third generation (3G) technology marked the introduction of high-speed internet access, mobile video calling, and location-based services. The fourth generation (4G) technology revolutionized wireless communication with faster data speeds, improved network coverage, and security. Currently, fifth generation (5G) technology is being deployed, offering significantly faster data speeds, lower latency, and the ability to connect many devices simultaneously. These advancements represent a significant leap forward from previous generations, enabling enhanced mobile broadband, improved Internet of Things (loT) connectivity, and more efficient use of network resources. The sixth generation (6G) technology promises to build upon these advancements, pushing theboundaries of wireless communication even further. While the 5G technology is still being rolled out globally, research and development into the 6G are rapidly progressing, with the aim of revolutionizing the way to connect and interact with technology.

[0064] In modern telecommunication networks, particularly in 5G and beyond, managing overload conditions within network functions is critical for ensuring reliable performance and maintaining service quality. With the increasing complexity and demands placed on network function, such as the Policy Control Function (PCF), Binding Support Function (BSF), Charging Function (CHF), and Network Repository Function (NRF), is essential to effectively manage and monitor resources to prevent overload situations that can degrade network performance.

[0065] One of the primary challenges is the management of object pools within these network functions. Object pooling is a technique used to improve the efficiency of resource utilization by reusing objects rather than creating and destroying them repeatedly. However, when the demand for objects exceeds the capacity of the pool, it may lead to an overload condition where a network function may experience delays or failures in processing requests due to the unavailability of necessary resources.

[0066] In conventional approaches, monitoring the usage of object pools and detecting overload conditions often lacks the precision and real-time responsiveness needed to effectively manage such scenarios. The failure to quickly detect and address overload conditions can result in service disruptions, reduced quality of service, and potential loss of data. Additionally, existing systems may not provide adequate mechanisms for triggering alarms or taking corrective actions when predefined thresholds are breached, leading to delayed responses and further exacerbating the problem.

[0067] To address these challenges, the present disclosure provides a method and system for managing overload conditions in network functions through the effectivemonitoring and management of the object pools. The disclosed method involves monitoring a counter associated with borrowing of one or more objects from a pool, in particular, monitoring the number of instances currently borrowed from the pool by the network function, storing the number of borrowed objects after every second in a list, and calculating an average count of the objects borrowed over a predefined time period using the list to detect the overload condition. Furthermore, the method triggers a conditional alarm when the average count is breached, i.e., when borrowing of objects exceeds a threshold value over the predefined time period, enabling timely intervention and mitigating the impact of the overload on network performance. The approach ensures that a network function operates efficiently under varying load conditions, enhancing the overall reliability and robustness of the telecommunication network.

[0068] Hereinafter, exemplary embodiments of the present disclosure will be described with reference to the accompanying drawings. The various embodiments throughout the disclosure will be explained in more detail with reference to FIG. 1- FIG. 5.

[0069] FIG. 1 illustrates an exemplary network architecture (100) of a system (108) for generating a conditional alarm in a network (106), in accordance with an embodiment of the present disclosure.

[0070] As illustrated in FIG. 1, the network architecture (100) may include one or more user equipment (UE) (104-1, 104-2... 104-N) associated with one or more users (102-1, 102-2... 102-N) in an environment. A person of ordinary skill in the art will understand that one or more users (102-1, 102-2... 102-N) may collectively referred to as the users (102). Similarly, a person of ordinary skill in the art will understand that one or more UEs (104-1, 104-2... 104-N) may be collectively referred to as the UE (104). Although only three UEs (104) are depicted in FIG. 1, however, any number of the UE (104) may be included without departing from the scope of the ongoing description.

[0071] In an embodiment, the UE (104) may include smart devices operating in a smart environment, for example, an Internet of Things (loT) system. In such an embodiment, the UE (104) may include, but is not limited to, smartphones, smart watches, smart sensors (e.g., mechanical, thermal, electrical, magnetic, etc.), networked appliances, networked peripheral devices, networked lighting system, communication devices, networked vehicle accessories, networked vehicular devices, smart accessories, tablets, smart television (TV), computers, smart security system, smart home system, other devices for monitoring or interacting with or for the users (102) and / or entities, or any combination thereof. A person of ordinary skill in the art will appreciate that the UE (104) may include, but not limited to, intelligent, multisensing, network- connected devices, that may integrate seamlessly with each other and / or with a central server or a cloud- computing system or any other device that is network-connected.

[0072] Additionally, in some embodiments, the UE (104) may include, but not limited to, a handheld wireless communication device (e.g., a mobile phone, a smartphone, a phablet device, and so on), a wearable computer device (e.g., a headmounted display computer device, a head-mounted camera device, a wristwatch computer device, and so on), a Global Positioning System (GPS) device, a laptop computer, a tablet computer, or another type of portable computer, a media playing device, a portable gaming system, and / or any other type of computer device with wireless communication capabilities, and the like. In an embodiment, the UE (104) may include, but are not limited to, any electrical, electronic, electromechanical, or equipment, or a combination of one or more of the above devices, such as virtual reality (VR) devices, augmented reality (AR) devices, laptop, a general-purpose computer, desktop, personal digital assistant, tablet computer, mainframe computer, or any other computing device, where the UE (104) may include one or more in-built or externally coupled accessories including, but not limited to, a visual aid device such as a camera, an audio aid, a microphone, a keyboard, and input devices for receiving input from the user (102) or the entity such as touchpad, touch-enabled screen, electronic pen, and thelike. A person of ordinary skill in the art will appreciate that the UE (104) may not be restricted to the mentioned devices and various other devices may be used.

[0073] Referring to FIG. 1, the UE (104) may communicate with the system (108) through a network (also referred to as a telecommunication network) (106) for sending or receiving various types of data. In an embodiment, the network (106) may include at least one of a 5G network, 6G network, or the like. The network (106) may enable the UE (104) to communicate with other devices in the network architecture (100) and / or with the system (108). The network (106) may include a wireless card or some other transceiver connection to facilitate this communication. In another embodiment, the network (106) may be implemented as, or include any of a variety of different communication technologies such as a wide area network (WAN), a local area network (LAN), a wireless network, a mobile network, a Virtual Private Network (VPN), the Internet, the Public Switched Telephone Network (PSTN), or the like.

[0074] In an embodiment, the network (106) may include, by way of example but not limitation, at least a portion of one or more networks having one or more nodes that transmit, receive, forward, generate, buffer, store, route, switch, process, or a combination thereof, etc. one or more messages, packets, signals, waves, voltage or current levels, some combination thereof, or so forth. The network (106) may also include, by way of example but not limitation, one or more of a wireless network, a wired network, an internet, an intranet, a public network, a private network, a packet- switched network, a circuit-switched network, an ad hoc network, an infrastructure network, a Public-Switched Telephone Network (PSTN), a cable network, a cellular network, a satellite network, a fiber optic network, or some combination thereof.

[0075] In an embodiment, the UE (104) is communicatively coupled with the network (106). The network (106) may receive a connection request from the UE (104). The network (106) may send an acknowledgment of the connection request to the UE (104). The UE (104) may transmit a plurality of signals in response to the connection request

[0076] Although FIG. 1 shows exemplary components of the network architecture (100), in other embodiments, the network architecture (100) may include fewer components, different components, differently arranged components, or additional functional components than depicted in FIG. 1. Additionally, or alternatively, one or more components of the network architecture (100) may perform functions described as being performed by one or more other components of the network architecture (100).

[0077] FIG. 2 illustrates an exemplary block diagram (200) of the system (108) configured for generating the conditional alarm in the network (106), in accordance with an embodiment of the present disclosure.

[0078] Referring to FIG. 2, in an embodiment, the system (108) may include one or more processor(s) (202). The one or more processor(s) (202) may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, logic circuitries, and / or any devices that process data based on operational instructions. Among other capabilities, the one or more processor(s) (202) may be configured to fetch and execute computer-readable instructions stored in a memory (204) of the system (108). The memory (204) may be configured to store one or more computer-readable instructions or routines in a non- transitory computer readable storage medium, which may be fetched and executed to create or share data packets over a network service. The memory (204) may include any non-transitory storage device including, for example, volatile memory such as random-access memory (RAM), or non-volatile memory such as erasable programmable read only memory (EPROM), flash memory, and the like.

[0079] In an embodiment, the system (108) may include an interface(s) (206). The interface(s) (206) may include a variety of interfaces, for example, interfaces for data input and output devices (I / O), storage devices, and the like. The interface(s) (206) may facilitate communication through the system (108). The interface(s) (206) may also provide a communication pathway for one or more components of the system (108).Examples of such components include, but are not limited to, a processing engine (208) and a database (210).

[0080] In an embodiment, the system (108) may include the processing engine (208) that may be implemented as a combination of hardware and programming (for example, programmable instructions) to implement one or more functionalities of the processing engine (208). In the examples described herein, such combinations of hardware and programming may be implemented in several different ways. For example, the programming for the processing engine (208) may be processorexecutable instructions stored on a non-transitory machine-readable storage medium and the hardware for the processing engine (208) may comprise a processing resource (for example, one or more processors), to execute such instructions. In the present examples, the machine-readable storage medium may store instructions that, when executed by the processing resource, implement the processing engine (208). In such examples, the system (108) may include the machine-readable storage medium storing the instructions and the processing resource to execute the instructions, or the machine- readable storage medium may be separate but accessible to the system (108) and the processing resource. In other examples, the processing engine (208) may be implemented by electronic circuitry.

[0081] In an embodiment, the system (108) may include a network function. Examples of the network function may include, but are not limited to, the PCF, the BSF, the CHF, and the NRF. The network function may include a processing engine (208). In some embodiments, the processing engine 208 may be a Fault, Configuration, Accounting, Performance, and Security management (FCAPS) module. The FCAPS module is a microservice used in network management that provides a comprehensive approach for managing and monitoring a health, configuration, usage, performance, and security of various network resources. Further, the processing engine (208) may include a requesting unit (212), a maintaining unit (214), a storing unit (216), a calculating unit (218), a comparing unit (220), and a generating unit (222).

[0082] In an embodiment, the requesting unit (212) of the processing engine (208) is configured to request one or more objects to be borrowed from an object pool. In an example, the requesting unit (212) may receive the request from the network function requiring an object (e.g., for temporary data handling or processing state). The one or more borrowed objects may include at least one of a thread, a database connection, a network socket, and a memory buffer. The thread may be an execution unit within the network function. The database connection may be a link to a database, which is often pooled for performance. Further, the network socket may be an endpoint for network communication. The memory buffer may be a temporary storage area used during data processing. In an aspect, the objects may be the network resources required by the network function to perform its operations efficiently. The objects may be stored in an object pool, which may be shared by the plurality of network functions such as the PCF, BSF, NRF, etc. The object pool may act as a centralized database of the objects (network resources) which may be queried by the network function to retrieve the required object. The object pool may be a collection of pre-initialized objects (e.g., threads, or database connections) that are ready to be used by the network function. When the network function needs a resource, the network function borrows the object from the pool, uses the object, and then returns the object to the object pool when finished. Consider an example where a UE connects to a network and wants to stream a video. The PCF, to determine which policy for a session associated with the UE, may request an object for video streaming through requesting unit (212). The object may be database link to a predefined policy template.

[0083] In an embodiment, the processing engine (208) may configure the object pool with a set of parameters to manage a borrowing of the one or more objects. The set of parameters may include a maxActive parameter, a maxidie, and a maxWait parameter. Further, the maxActive parameter defines a maximum number of objects that can be actively borrowed from the pool at any given time. If the number of active objects reaches the maxActive parameter limit, additional requests to borrow objects may either be queued or rejected, depending on the configuration. The maxActiveparameter is used in preventing resource exhaustion and ensuring that the system operates within its capacity limits, reducing the risk of overload conditions. The maxldle parameter specifies the maximum number of idle objects that can be maintained in the pool. The Idle objects are the objects that have been returned or are present in the pool but are not currently in use. Keeping a defined number of idle objects allows for quicker response times when new requests are made, as these objects are readily available without needing to be reinitialized. However, limiting the number of idle objects ensures that system resources are not wasted on maintaining unnecessary objects, which can improve overall efficiency. Further, the maxWait parameter defines the maximum number of objects waiting to be pooled when the pool has reached its maxActive limit. If the number of waiting objects exceeds the maxWait limit, any further requests may be rejected, indicating that the system is under significant load or may be approaching an overload condition. By configuring maxWait appropriately, the system may better manage high-traffic scenarios, ensuring that resources are allocated efficiently while avoiding prolonged delays or failures.

[0084] In an embodiment, the maintaining unit (214) of the processing engine (208) is configured to maintain a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The at least one operation includes one of incrementing the counter value corresponding to an object upon borrowing the object from the object pool and decrementing the counter value corresponding to the object upon returning a borrowed object to the object pool. In particular, the maintaining unit (214) may monitor a counter associated with an object pool. A value of the counter indicates a number of objects borrowed by the network function from the object pool. The maintaining unit (214) tracks how many objects are being borrowed or a number of instances currently borrowed from the pool and used by the network function (e.g., PCF, BSF, CHF, NRF). Whenever the network function borrows an object from the pool, the counter is incremented. For instance, if the network function (e.g., the PCF) borrows a single object from the pool, the counter value is initially set to 1. The counter value represents the number of objects currentlyborrowed by that particular network function. Each subsequent borrowing of additional objects by the same or different network function results in a corresponding increment in the counter value. The maintaining unit (214) continuously updates these counters, ensuring real-time tracking of the borrowing activity.

[0085] To further elaborate, consider a scenario where the network function borrows the object from the object pool. At the initial borrowing instance, the counter value is set to 1, indicating that one object is currently borrowed and in use. If the network function continues to borrow more objects without returning the previously borrowed ones, the counter value increases accordingly. For example, if two more objects are borrowed without any object being returned, the counter value will rise to 3. The counter incrementation continues as long as the network function keeps borrowing objects without returning them to the pool.

[0086] In an embodiment, the storing unit (216) of the processing engine (208) is configured to store the counter value corresponding to each of one or more borrowed objects in a database. The counter value corresponding to each object is stored in the database as a list and is updated at a regular time period. In an example, the storing unit (216) may store the counter value (i.e., the number of objects borrowed) in a list at a regular time interval (e.g., after every second of monitoring the counters). In an aspect, the list acts as a record of all instances borrowing from the object pool. In an exemplary embodiment, consider a network function, such as the PCF that monitors an object pool. As the PCF operates, the maintaining unit (214) monitors the number of objects borrowed from the object pool and stores these counter values in the list at regular intervals (e.g., every second). In an example, the list of counter values may look like: [101, 102, 100, 104, 105, 106, 101, 99, 98, 97], Each value in the list represents the number of objects borrowed at that specific time interval.

[0087] In an embodiment, the calculating unit (218) of the processing engine (208) is configured to calculate an average count of the one or more borrowed objects based on the stored counter value. In an aspect, the average count is calculated by dividing asum of the counter value stored as the list by a number of selected entries from the list in the database. In an example, the calculating unit (218) may calculate an average count of the one or more objects borrowed over a predefined time period using the stored counter value to detect the overload condition. The calculating unit (218) may have the flexibility to calculate the average count at particular intervals, which may be dynamic or preconfigured. The calculation provides information to distinguish between the one-time spike and the true overload condition. The number of entries considered for the average count may be dynamic, allowing the processing engine (208) to decide how many recent entries should be used in the calculation.

[0088] For example, even if there are 10 entries in the list, the calculating unit (218) may choose to calculate the average using only the latest 5 entries. In other words, the system (108) offers flexibility in how the calculating unit (218) manages and stores counter values. If the average count calculation uses only 5 entries, the storing unit (216) may choose to store only these 5 latest entries in the list, discarding older values to optimize memory usage.

[0089] In the exemplary scenario, if the calculating unit (218) is configured to calculate the average based on the latest 5 entries, the calculating unit (218) may consider the last 5 values in the list, i.e., [106, 101, 99, 98, 97], The sum of these values is 501. The calculating unit (218) then divides the sum by the number of entries, which is 5 in this case, resulting in an average count of 100.2.

[0090] In an embodiment, the comparing unit (220) of the processing engine (208) is configured to compare the calculated average count with a preconfigured value. The comparing unit (220) determines whether the calculated average count, which is calculated using the counter value stored in the list, exceeds a predefined threshold value. In another embodiment, the processing engine (208) may define a threshold for each object in the object pool, such as the active objects, idle objects, and waiting objects. The threshold represents the maximum number of times an object can be borrowed from the object pool. The threshold value acts as a permissible limit,indicating the maximum number of objects that the network function (such as the PCF) can borrow from the object pool without triggering an alarm. When the counter value exceeds the predefined threshold value, signifies a breach of the threshold. The breach indicates that the network function is borrowing more resources than what is considered safe or optimal, potentially leading to an overload condition. The breach of the threshold value corresponds to an increase in the counter value above the predefined threshold value. In an aspect, the network function (e.g., PCF) may set the threshold value corresponding to the permissible limit of the network function to borrow the object from the pool. In an example, the threshold value is dynamic and may vary based on the network function requirement. For example, during periods of high demand, the threshold may be adjusted upward to accommodate increased borrowing without triggering unnecessary alarms. Conversely, during normal or low-demand periods, the threshold may be lowered to maintain tighter control over resource usage. Further, the comparing unit (220) may periodically check whether the calculated average count associated with the object pool exceeds the preconfigured value.

[0091] In an exemplary embodiment, to determine whether the average count has been breached, the calculated average count (e.g., 100.2) is compared to the predefined threshold value (e.g., 100). If the average count exceeds the predefined threshold value, it indicates that the object borrowing has consistently been above the permissible limit, rather than being a random occurrence. Since the average count (100.2) exceeds the predefined threshold value (100), the comparing unit (220) recognizes the instance as a true overload condition.

[0092] In an embodiment, the generating unit (222) of the processing engine (208) is configured to generate the conditional alarm if the calculated average count exceeds the preconfigured value. The generated conditional alarm indicates an occurrence of at least one overload condition in the network (106). In an example, the generating unit (222) may raise an alarm in an event when the average count exceeds the predefined threshold value (i.e., the average count breach condition). For example, if the1 predefined threshold value is set at 100, and the calculated average count (100.2) exceeds the predefined threshold, the processing engine (208) may recognize the instance as an indication of consistent overuse of resources, rather than an isolated incident. As a result, the generating unit (222) raises an alarm (e.g., a conditional alarm) to alert network administrators regarding the overload situation. In an embodiment, the alarms may correspond to visual notification, audio notification, audio-visual notification, or a combination thereof.

[0093] In another embodiment, the processing engine (208) may be configured to display the generated conditional alarm and the list on a User Interface (UI) to notify the user (102). The user (102) may be able to see the generated conditional alarm and the list on the UI of the UE (104). Further, the UE (104) may be a network operator authorized device configured to display the conditional alarm and the list to the network operator authorized user (102).

[0094] In some embodiments, the overload condition of the network function may be managed by considering a scenario of a counter threshold value associated with the counter. In such a scenario, the comparing unit (220) may check whether the counter value associated with the one or more borrowed objects exceeds the counter threshold value. The counter threshold value acts as a permissible limit, indicating the maximum number of objects that the network function (such as the PCF) can borrow from the object pool without triggering an alarm. When the counter value exceeds the counter threshold value, it signifies a breach of the threshold. The breach indicates that the network function is borrowing more resources than what is considered safe or optimal, potentially leading to an overload condition. The breach of the counter threshold value corresponds to an increase in the counter value above the counter threshold value.

[0095] By way of an example, consider a scenario where the counter threshold value for borrowing resources is set at 300 objects. As the network function continues to borrow resources, the counter value increases. If the counter value reaches 301, this indicates that the number of borrowed objects has exceeded the counter's predefinedthreshold of 300. At this point, the comparing unit (220) recognizes this as a breach of the threshold.

[0096] In an aspect, each time the counter threshold is breached, the corresponding counter value (i.e., the number of objects borrowed) is stored in a list. The list acts as a record of all instances where the borrowing exceeded the counter threshold, capturing the extent of each breach.

[0097] Upon determining that the counter has exceeded the counter threshold value, the generating unit (222) does not immediately raise an alarm. Instead, the comparing unit (220) checks whether the counter threshold breach is consistent and significant by calculating an average count. The calculating unit (218) may calculate an average count of the one or more objects borrowed over a predefined time period to detect the overload condition. The average count is calculated based on the number of times the counter threshold has been breached over a specific period. The average count is calculated by taking the sum of all the counter values stored in the list and dividing it by the number of entries in that list, helping in distinguishing between a one-time spike and a true overload condition.

[0098] For the sake of explanation, consider a scenario of the network function, such as the PCF that monitors an object pool that has a predefined threshold value set at 100. The predefined threshold means that borrowing more than 100 objects from the pool by the network function at any given time is considered as the breach of the threshold. Over a period of time, the counter value reaches 101, indicating that the threshold of 100 has been breached. Instead of immediately raising an alarm, the storing unit (216) records the breach and calculates the average count. Each time the threshold is breached, the storing unit (216) stores the counter value in a list. For instance, if the threshold is breached five times in a monitoring period, the list may contain the values [101, 105, 110, 102, 108],

[0099] The calculating unit (218) further calculates the average count of the recorded breach values. Suppose the calculating unit (218) is configured to calculate the average over a predefined time period of five intervals. The recorded values during these intervals are summed up (101 + 105 + 110 + 102 + 108 = 526), and then the total is divided by the number of breaches (in this case, 5), giving an average count of 105.2.

[0100] Further, the generating unit (222) may raise an alarm if the average count exceeds a predefined threshold value (i.e., the average count breach condition), For example, if the predefined threshold value is set at 104, and the calculated average count (105.2) exceeds the predefined threshold, the calculating unit (218) may recognize this as an indication of consistent overuse of resources, rather than an isolated incident.

[0101] In an embodiment, the average count exceeds the predefined threshold value when the borrowing of the objects consistently surpasses the counter threshold value over the predefined time period. The predefined threshold value for the average count serves as a safeguard to ensure that the alarm is raised only when there is actually a breach of resource usage, reducing the likelihood of false alarms.

[0102] Further, to determine whether the average count has been breached, the calculated average count (e.g., 105.2) is then compared to the predefined threshold value (e.g., 104). If the average count exceeds the predefined threshold value, it indicates that the object borrowing has consistently been above the permissible limit, rather than being a random occurrence. Since the average count (105.2) exceeds the predefined threshold value (104), the generating unit (222) recognizes the instance as a true overload condition. As a result, the generating unit (222) raises an alarm (e.g., a conditional alarm) to alert network administrators regarding the overload situation.

[0103] In an exemplary embodiment, consider a bustling metropolitan area where a 5G network operator manages a dense network of users relying on seamless data services for streaming, gaming, and remote work. The operator’s 5G core includesnetwork functions like a Policy Control Function (PCF), a Binding Support Function (BSF), a Charging Function (CHF), and a Network Repository Function (NRF), which utilize object pools to manage resources such as database connections or threads. During a major event, such as a city-wide festival, thousands of users simultaneously access the network to upload videos and live stream, causing a sudden spike in traffic. The sudden spike in traffic leads to a rapid increase in object borrowing from the PCF’s object pool, risking overload as the permissible borrowing limit is breached, potentially degrading service quality or causing outages.

[0104] However, the PCF, configured with the enhanced pooling functionality, monitors object borrowing in real-time using predefined thresholds set at application startup. As the festival traffic surges, the PCF detects that the number of borrowed objects exceeds a predefined threshold. Instead of immediately raising an alarm, the 5G network logs multiple instances of the breach, calculates an average, and confirms a genuine overload condition persisting over time, avoiding false alarms from temporary spikes during initialization. Once confirmed, a conditional alarm is triggered and logged, visible via the operator’s Graphical User Interface (GUI). Further, the network team is alerted to the issue which may quickly scale resources by adding more nodes to the PCF cluster, preventing service degradation. The data collected from the monitoring also aids future network planning, helping the 5G network operator predict and prepare for similar high-traffic events, ensuring consistent performance and an enhanced user experience during peak usage scenarios.

[0105] In an embodiment, the system (108) may include a database (210) that includes a wide range of information essential for generating the conditional alarm that may be either stored or generated as a result of functionalities implemented by any of the components of the system (108).

[0106] Although FIG. 2 shows exemplary components of the system (108), in other embodiments, the system (108) may include fewer components, different components, differently arranged components, or additional functional componentsthan depicted in FIG. 2. Additionally, or alternatively, one or more components of the system (108) may perform functions described as being performed by one or more other components of the system (108).

[0107] FIG. 3A illustrates an exemplary flow diagram of a method (300A) for generating the conditional alarm in the network (106), in accordance with an embodiment of the present disclosure. FIG. 3A is explained in conjunction with the FIGs. 1 and 2. Each step of the method (300A) may be performed by various units (e.g., the requesting unit (212), the maintaining unit (214), the storing unit (216), the calculating unit (218), the comparing unit (220), and the generating unit (222)) present within the processing engine (208) of the system (108). The method (300A) aims to generate the conditional alarm in the network (106), ensuring that the network function maintains stable connectivity with optimal resources, thereby enhancing overall network performance. The elements and steps described in the figure are part of a process implemented within the network function, which acts as a central system for data aggregation, analysis, and decision-making. Examples of the network function may include, but are not limited to, the PCF, BSF, CHF, and NRF. Further, the method (300A) is explained in accordance with the PCF as the network function, which is applicable to other network functions as well.

[0108] As illustrated in FIG. 3A, the flow diagram begins at step (302A), which initiates the method (300 A) for generating the conditional alarm in the network (106). At step (304A), the PCF continuously monitors the counters for conditional alarms. In particular, the counters track the number of instances of the objects being borrowed from an object pool.

[0109] At step (306A), the PCF stores the counter value (i.e., the number of borrowed objects) at a regular time interval in a list. The list of the counter values acts as a record of borrowing objects, allowing the PCF to track trends over time.

[0110] At step (308 A), the PCF checks whether the average count, calculated at a particular interval, has breached a predefined threshold value. The predefined threshold value represents the permissible limit of objects that can be borrowed without causing an overload on the resources. In an aspect, the PCF uses existing pooling functionality to set the predefined threshold value for object pooled. The pooling functionality may configure the object pool at the bootstrap of the PCF, with a single point of accessibility. The object pool may be configured with parameters such as maxActive, maxidie, or maxWait. In an aspect, the average count of the objects borrowed is calculated over a predefined time period using the list of the stored counter values and represents the consistency and significance of the threshold breaches. If the average count is not breached, the PCF continues monitoring the counters without raising an alarm, going back to step (304 A). However, if the average count is breached, indicating an overload condition.

[0111] At step (310A), the PCF raises a conditional alarm to alert the network operators about the overload condition. The conditional alarm indicates that the PCF has consistently been borrowing more objects than the threshold allows, signaling a need for attention or corrective action.

[0112] At step (312A), the raised alarm is displayed in a Graphical User Interface (GUI) or Command Line Interface (CLI) for the network operators to view and take necessary actions (e.g., reset).

[0113] FIG. 3B illustrates another exemplary flow diagram of a method (300B) for generating the conditional alarm in the network (106), in accordance with an embodiment of the present disclosure. FIG. 3B is explained in conjunction with the FIGs. 1, 2, and 3 A. Each step of the method 300B may be performed by various units (e.g., the requesting unit (212), the maintaining unit (214), the storing unit (216), the calculating unit (218), the comparing unit (220), and the generating unit (222)) present within the processing engine (208) of the system (108). The method (300B) is defined to generate the conditional alarm in the network (106), ensuring that the networkfunction maintains stable connectivity with optimal resources, thereby enhancing overall network performance. The elements and steps described in the figure are part of a process implemented within the network function, which acts as a central system for data aggregation, analysis, and decision-making. In an embodiment, the method (300B) considers the counter threshold value for generating the conditional alarm in the network (106). Further, the method (300B) is explained in accordance with the PCF as the network function.

[0114] The flow diagram begins at step (302B), which initiates the method (300B) for generating the conditional alarm in the network (106). At step (304B), the PCF continuously monitors the counters for conditional alarms. In particular, the counters track the number of instances of the objects being borrowed from an object pool.

[0115] At step (306B), the PCF checks whether the counter has breached the counter threshold value. The counter threshold value represents the permissible limit for the number of objects that can be borrowed from the object pool without causing an overload on the resources. In an aspect, the PCF uses existing pooling functionality to set the counter threshold value for the object pool. If the counter threshold is not breached, the PCF keeps on monitoring the counter by going back to step (304B). However, if the counter threshold is breached, the method moves to the next step (308B).

[0116] At step (308B), the PCF checks whether the average count has been breached. The average count of the objects borrowed is calculated over a predefined time period and represents the consistency and significance of the threshold breaches. If the average count is not breached, the PCF continues monitoring the counters without raising an alarm. However, if the average count is breached, indicating an overload condition.

[0117] At step (310B), the PCF raises a conditional alarm to alert the network operators about the overload condition. The conditional alarm indicates that the PCFhas consistently been borrowing more objects than the threshold allows, signaling a need for attention or corrective action.

[0118] At step (312B), the raised alarm is displayed in the GUI or CLI for the network operators to view and take necessary actions (e.g., reset), ensuring that the overload condition is quickly addressed to prevent any further issues.

[0119] FIG. 4 illustrates another exemplary flow diagram of a method (400) for generating the conditional alarm in the network (106), in accordance with an embodiment of the present disclosure. FIG. 4 is explained in conjunction with the FIGs. 1, 2, 3 A, and 3B. Each step of the method (400) may be performed by various units (e.g., the requesting unit (212), the maintaining unit (214), the storing unit (216), the calculating unit (218), the comparing unit (220), and the generating unit (222)) present within the processing engine (208) of the system (108). The method (400) aims to generate the conditional alarm in the network (106), ensuring that the network function maintains stable connectivity with optimal resources, thereby enhancing overall network performance. The elements and steps described in the figure are part of a process implemented within the network function, which acts as a central system for data aggregation, analysis, and decision-making.

[0120] At step (402), one or more objects are requested to be borrowed from an object pool. The object pool is configured with a set of parameters to manage a borrowing of the one or more objects. The set of parameters may include a maxActive parameter indicating a maximum number of active objects that are available to be borrowed from the object pool, a maxldle indicating a maximum number of idle objects present in the object pool, and a maxWait parameter indicating a maximum number of objects waiting to be borrowed. Further, a threshold is defined for each object in the object pool. The threshold represents a maximum number of borrowing of the object from the object pool.

[0121] At step (404), a counter value is maintained corresponding to each of the one or more objects borrowed from the object pool based on at least one operation. The counter value corresponding to each object is stored in the database as a list and is updated at a regular time period. The at least one operation may include one of incrementing the counter value corresponding to an object upon borrowing the object from the object pool and decrementing the counter value corresponding to the object upon returning a borrowed object to the object pool. In an embodiment, the method (400) keeps track of how frequently each object in the object pool is borrowed and returned by maintaining a counter value for each object. The counter helps monitor object usage over time and detect patterns that might indicate abnormal or excessive resource usage. In some embodiments, each object that is borrowed from the object pool may have an associated counter. The counter records the number of times that a particular object has been borrowed.

[0122] At step (406), the counter value corresponding to each of one or more borrowed objects is stored in a database. The one or more borrowed objects may include at least one of a thread, a database connection, a network socket, and a memory buffer. By storing the counter values in the database, the system ensures that object usage data is not lost between network function restarts or failures. In some embodiments, the database may store the counter value as part of a list which may be indexed or mapped by object Identifier (ID) or object type such as thread, a database connection, a network socket, and a memory buffer.

[0123] At step (408), an average count of the one or more borrowed objects is calculated based on the stored counter value. The average count is calculated by dividing a sum of the counter value stored as the list by a number of selected entries from the list in the database. The average count may provide a smoothed representation of object borrowing activity. Instead of reacting to a single spike in usage, the method (400) uses the averaged count value to make more stable, intelligent decisions about whether to raise alarms or scale network resources.

[0124] At step (410), the calculated average count is compared with a preconfigured value. The method (400) may periodically check whether the calculated average count associated with the object pool exceeds the preconfigured value, if the calculated average count does not exceed the preconfigured value. The preconfigured value indicates a permissible limit for the one or more objects borrowed from the object pool.

[0125] At step (412), the conditional alarm is generated if the calculated average count exceeds the preconfigured value. The generated conditional alarm indicates an occurrence of at least one overload condition in the network. When the conditional alarm is triggered, it signals that at least one overload condition exists within the network function, allowing operators or automated systems to investigate, mitigate the load, scale resources, or take preventive measures.

[0126] In an embodiment, the method (400) may further display the generated conditional alarm and the list on a user interface (UI) to notify a user (102). The UI may include a visual indicator such as a notification, alert banner, or warning icon signaling that a threshold breach has occurred. Further, the UI may allow the user to take immediate action (such as scaling resources, adjusting thresholds), analyze historical or current usage trends, and reset or acknowledge alarms through a Graphical UI or a Command-Uine Interface (GUI / CUI).

[0127] In an exemplary embodiment, consider a telecommunications service provider operating a 5G network infrastructure that includes multiple network functions such as the PCF, the BSF, and the NRF. These network functions utilize an object pool to manage reusable resources like database connections and processing threads. During peak network usage hours, particularly after a regional power restoration event, a large number of user devices simultaneously attempt to reattach to the network, resulting in a surge of initialization requests that require the network functions to borrow a high volume of resources from the object pool. In such a scenario, the present disclosure begins monitoring the borrowing patterns of the objects. Eachtime a database connection or thread is borrowed from the object pool, a counter associated with that resource type is incremented. Similarly, when the resource is returned, the counter is decremented. The counters are periodically stored and updated in a central database. The present disclosure further calculates the average borrowing rate over several monitoring intervals. The average is then compared with a predefined threshold configured for each type of object. If the average borrowing rate exceeds the threshold indicating sustained high resource demand, a conditional alarm is triggered. The alarm is then displayed on the network operations center's dashboard, along with the list of recent counter values. The alarm alerts network engineers to a possible overload condition. Further, the network engineer then takes preventive action, such as scaling out additional instances of the affected network function or temporarily throttling incoming requests to maintain service stability.

[0128] FIG. 5 illustrates an exemplary computer system (500) in which or with which embodiments of the present disclosure may be implemented.

[0129] As shown in FIG. 5, the computer system (500) may include an external storage device (510), a bus (520), a main memory (530), a read-only memory (540), a mass storage device (550), a communication port (560), and a processor (570). A person skilled in the art will appreciate that the computer system (500) may include more than one processor (570) and communication ports (560). The processor (570) may include various modules associated with embodiments of the present disclosure.

[0130] In an embodiment, the communication port (560) may be any of an RS-232 port for use with a modem-based dialup connection, a 10 / 100 Ethernet port, a Gigabit or 10 Gigabit port using copper or fibre, a serial port, a parallel port, or other existing or future ports. The communication port (560) may be chosen depending on the network (106), such a Local Area Network (LAN), Wide Area Network (WAN), or any network to which the computer system (500) connects.

[0131] In an embodiment, the memory (530) may be Random Access Memory (RAM), or any other dynamic storage device commonly known in the art. Read-only memory (540) may be any static storage device(s) e.g., but not limited to, a Programmable Read Only Memory (PROM) chips for storing static information e.g., start-up or Basic Input / Output System (BIOS) instructions for the processor (570).

[0132] In an embodiment, the mass storage (550) may be any current or future mass storage solution, which may be used to store information and / or instructions. Exemplary mass storage solutions include, but are not limited to, Parallel Advanced Technology Attachment (PATA) or Serial Advanced Technology Attachment (SATA) hard disk drives or solid-state drives (internal or external, e.g., having Universal Serial Bus (USB) and / or Firewire interfaces), one or more optical discs, Redundant Array of Independent Disks (RAID) storage, e.g., an array of disks (e.g., SATA arrays).

[0133] In an embodiment, the bus (520) communicatively couples the processor(s) (570) with the other memory, storage, and communication blocks. The bus (520) may be, e.g., a Peripheral Component Interconnect (PCI) / PCI Extended (PCI-X) bus, Small Computer System Interface (SCSI), Universal Serial Bus (USB) or the like, for connecting expansion cards, drives and other subsystems as well as other buses, such a front side bus (FSB), which connects the processor (570) to the computer system (500).

[0134] Optionally, operator and administrative interfaces, e.g., a display, keyboard, joystick, and cursor control device, may also be coupled to the bus (520) to support direct operator interaction with the computer system (500). Other operator and administrative interfaces may be provided through network connections connected through the communication port (560). The components described above are meant only to exemplify various possibilities. In no way should the aforementioned exemplary computer system (500) limit the scope of the present disclosure.

[0135] In an embodiment, a computer program product including a non-transitory computer-readable medium includes instructions that, when executed by one or more processors, cause the one or more processors to perform a method for generating the conditional alarm in the network. The method includes requesting one or more objects to be borrowed from an object pool. Further, the method includes maintaining a counter value corresponding to each of the one or more objects borrowed from the object pool. The method further includes storing the counter value corresponding to each of one or more borrowed objects in a database. Further, the method includes calculating an average count of the one or more borrowed objects based on the stored counter value. The method further includes comparing the calculated average count with a preconfigured value. Further, the method includes generating the conditional alarm if the calculated average count exceeds the preconfigured value.

[0136] The present disclosure provides technical advancement related to a system and method for generating a conditional alarm in a network. This advancement addresses the limitations of existing solutions by calculating an average count of the one or more borrowed objects and then comparing the calculated average count with a preconfigured value to determine if the network function is overloaded. The disclosure involves storing counter value corresponding to each of one or more borrowed objects, calculating average count of borrowed objects, comparing calculated average count, which offer significant improvements in operational performance, data handling efficiency, and cost-effectiveness. By implementing automated rule-driven calculation of overloading of the network functions, the present disclosure enhances the reliability, responsiveness, and efficiency of network resource management by enabling timely detection of sustained overload conditions, minimizing false alarms, and supporting proactive scaling and optimization of network functions.TECHNICAL ADVANTAGES

[0137] The present disclosure provides a method and a system for managing overload conditions in the network function.

[0138] The present disclosure benefits in determining genuine breaches of threshold values to be considered for raising object pool conditional alarms. Monitoring object borrowing from the pool is a valuable feature for ensuring efficient resource management and preventing overload situations in the network function.

[0139] The present disclosure provides an alarm system based on a predefined threshold that offers an effective means for the monitoring overload conditions without significantly affecting other interfaces. The benefits of integrating the alarm-based mechanism can be outlined as follows:

[0140] Prevents Irrelevant Alarms from Raising: By establishing threshold values and activating alarms, the system can avoid unnecessary alarms raised during node initialization and only consider threshold breaches that persist continuously for a given period. This helps in gaining clear insights into resource usage patterns, allowing for more informed decisions regarding resource allocation and scaling, ultimately leading to improved overall resource utilization.

[0141] Optimized Performance: Efficient resource management enables the network function to function at peak levels, delivering consistent and dependable services to end-users. This results in an elevated overall user experience and satisfaction.

[0142] Simple Implementation: The alarm-based monitoring system can be deployed with minimal complexity and limited impact on existing interfaces. The alarm-based monitoring system can be seamlessly integrated into the network function’s current resource management processes, ensuring a smooth and efficient implementation.

[0143] Enhanced Network Planning: Data gathered from the monitoring system can be analyzed to discern trends and usage patterns. This information is valuable for network planning, capacity forecasting, and optimization strategies, contributing to better resource allocation and improved network performance over time.

Claims

We claim:

1. A method (400) for generating a conditional alarm in a network (106), the method (400) comprising: requesting (402), by a network function, one or more objects to be borrowed from an object pool; maintaining (404), by the network function, a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation; storing (406), by the network function, the counter value corresponding to each of one or more borrowed objects in a database (210); calculating (408), by the network function, an average count of the one or more borrowed objects based on the stored counter value; comparing (410), by the network function, the calculated average count with a preconfigured value; and generating (412), by the network function, the conditional alarm if the calculated average count exceeds the preconfigured value.

2. The method (400) as claimed in claim 1, wherein the counter value corresponding to each object is stored in the database as a list and is updated at a regular time period.

3. The method (400) as claimed in claim 1 , wherein the average count is calculated by dividing a sum of the counter value stored as the list by a number of selected entries from the list in the database (210).

4. The method (400) as claimed in claim 1, wherein the one or more borrowed objects comprise at least one of a thread, a database connection, a network socket, and a memory buffer.

5. The method (400) as claimed in claim 1, comprising: periodically checking, by the network function, whether the calculated average count associated with the object pool exceeds the preconfigured value, wherein the preconfigured value indicates a permissible limit for the one or more objects borrowed from the object pool.

6. The method (400) as claimed in claim 1, wherein the generated conditional alarm indicates an occurrence of at least one overload condition in the network (106).

7. The method (400) as claimed in claim 1, comprising: displaying, by the network function, the generated conditional alarm and the list on a user interface (UI) to notify a user.

8. The method (400) as claimed in claim 1, comprising: configuring, by the network function, the object pool with a set of parameters to manage a borrowing of the one or more objects, wherein the set of parameters comprises a maxActive parameter indicating a maximum number of active objects that are available to be borrowed from the object pool, a maxldle indicating a maximum number of idle objects present in the object pool, and a maxWait parameter indicating a maximum number of objects waiting to be borrowed.

9. The method (400) as claimed in claim 8, comprising: defining, by the network function, a threshold for each object in the object pool, wherein the threshold represents a maximum number of borrowing of the object from the object pool.

10. The method (400) as claimed in claim 1, wherein the at least one operation comprises one of incrementing the counter value corresponding to an object upon borrowing the object from the object pool and decrementing the counter value corresponding to the object upon returning a borrowed object to the object pool.

11. A system (108) for generating a conditional alarm in a network (106), the system (106) comprising: a network function configured to request one or more objects to be borrowed from an object pool, and wherein the network function comprising; a memory (204) configured to store the one or more borrowed objects; and a processing engine (208) coupled to the memory (204), wherein the processing engine (208) is configured to receive the one or more borrowed objects from the memory (204) and execute instructions stored in the memory (204) to: maintain a counter value corresponding to each of the one or more objects borrowed from the object pool based on at least one operation; store the counter value corresponding to each of one or more borrowed objects in a database (210); calculate an average count of the one or more borrowed objects based on the stored counter value; compare the calculated average count with a preconfigured value; and generate the conditional alarm if the calculated average count exceeds the preconfigured value.

12. The system (108) as claimed in claim 11, wherein the counter value corresponding to each object is stored in the database (210) as a list and is updated at a regular time period.

13. The system (108) as claimed in claim 11, wherein the average count is calculated by dividing a sum of the counter value stored as the list by a number of selected entries from the list in the database (210).

14. The system (108) as claimed in claim 11, wherein the one or more borrowed objects comprise at least one of a thread, a database connection, a network socket, and a memory buffer.

15. The system (108) as claimed in claim 11, wherein the processing engine (208) is configured to: periodically check whether the calculated average count associated with the object pool exceeds the preconfigured value, wherein the preconfigured value indicates a permissible limit for the one or more objects borrowed from the object pool.

16. The system (108) as claimed in claim 11, wherein the processing engine (208) is configured to: display the generated conditional alarm and the list on a user interface (UI) to notify a user, wherein the generated conditional alarm indicates an occurrence of at least one overload condition in the network (106).

17. The system (108) as claimed in claim 11, wherein the processing engine (208) is configured to: configure the object pool with a set of parameters to manage a borrowing of the one or more objects, wherein the set of parameters comprises a maxActive parameter indicating a maximum number of active objects that are available to be borrowed from the object pool, a maxldle indicating a maximum number of idle objects present in the object pool, and a maxWait parameter indicating a maximum number of objects waiting to be borrowed.

18. The system (108) as claimed in claim 17, wherein the processing engine (208) is configured to: define a threshold for each object in the object pool, wherein the threshold represents a maximum number of borrowing of the object from the object pool.

19. The system (108) as claimed in claim 11, wherein the at least one operation comprises one of incrementing the counter value corresponding to an object upon borrowing the object from the object pool and decrementing the counter value corresponding to the object upon returning a borrowed object to the object pool.

20. A computer program product comprising a non-transitory computer-readable medium comprising instructions that, when executed by one or more processors (202), cause the one or more processors (202) to perform a method (400) for generating a conditional alarm in a network (106), the method (400) comprising: requesting (402), by a network function, one or more objects to be borrowed from an object pool; maintaining (404), by the network function, a counter value corresponding to each of the one or more objects borrowed from the object pool; storing (406), by the network function, the counter value corresponding to each of one or more borrowed objects in a database (210); calculating (408), by the network function, an average count of the one or more borrowed objects based on the stored counter value; comparing (410), by the network function, the calculated average count with a preconfigured value; and generating (412), by the network function, the conditional alarm if the calculated average count exceeds the preconfigured value.

Images