Contents


Monitor network bandwidth usage and analyze network traffic in the IBM AIX server using ProbeVue

Get in-depth information about the network traffic patterns including traffic volume, top talkers, bandwidth consumption, and high-usage times

Comments

IBM® AIX® ProbeVue is a dynamic tracing tool that helps system administrators to analyze their production systems. You can use multiple capabilities of ProbeVue together to get a holistic view of the system. This is a very useful tool for system administrators, application and system developers, and service engineers for system analysis.

ProbeVue provides multiple capabilities to analyze various areas of the system. ProbeVue users can debug network, process/thread, and storage I/O related issues by tracing at kernel layers. Users can also track the application flow and debug application-related issues such as memory leak, double free, and so on.

This article helps users to monitor network bandwidth and analyze network traffic in the AIX server using ProbeVue. This provides users with a near real-time view of what is happening in their network for a user-specified time interval or when a user-specified event occurs. This takes very less time to diagnose certain network issues compared to traditional tools, such as IPTRACE and TCPDUMP. This is because ProbeVue provides only the data requested by the user instead of providing the entire data, which requires a lot of time to analyze and diagnose a specific problem.

ProbeVue provides a holistic view of their network bandwidth usage and in-depth information about the network traffic patterns including traffic volume, top talkers, bandwidth consumption, high usage times, and so on. Some of the primary use cases to monitor the network bandwidth usage and traffic analysis are mentioned in this article.

Terminology

Refer to the following table for details about the terminologies used in this article.

Table 1. Terminology and description
Terminology Description
VUE This is the language in which ProbeVue scripts are written.
Probe point This identifies points during normal system activity that are capable of being traced or probed. A probe point can either be an event or a location in a code path that can be probed.
ProbeVue associative array data type Associative arrays are abstract data types in VUE. These are maps or look-up tables consisting of a collection of keys and their associated values.
Probe managers Probe managers are the providers of the probe points that can be instrumented by ProbeVue. They generally support a set of probe points that belong to some common area. These probe points that belong to a particular probe manager share some common features or attributes that distinguish them from other probe points. System call, network, and interval probe managers are used in this article.
ProbeVue timestamp data type This is a variable of type probev_timestamp_t and holds the return value from the timestamp() ProbeVue function. This returns a time stamp in an internal AIX format.

Note: Refer to the glossary for more information.

Primary use cases to monitor the network bandwidth and analyze the network traffic

Let us consider the following use cases:

  1. Identify the top 10 applications that consume maximum network bandwidth for a specified interval of time. Analyze ingress and egress traffic to figure out the top applications generating traffic on the network. User can drill down to find the top conversations and hosts for each application.
  2. Identify top 10 talkers and top 10 conversations that use maximum network bandwidth on the network for a specified interval of time.
  3. Monitor the network traffic for a specific interface. This provides the traffic IN and traffic OUT for each specified interface.
  4. Identify the peak bandwidth usage time period in a day. Analyze ingress and egress traffic for each hour in a day and then find out the maximum traffic usage period among those hours (Period X). User can drill down to find the top conversations that are contributing for peak traffic usage during that period X to get the peak hour.

Use case illustrations

  1. Identify the top 10 applications that consume maximum network bandwidth for a given period.

    Network administrators are in frequent need of a handy tool to monitor the applications that consume the maximum network bandwidth on the network.

    Refer to the following sample ProbeVue script to identify the top 10 applications that consume maximum network bandwidth on the network.

    This script can monitor network bandwidth and analyze network traffic in the AIX server.

    /* File name: bwidth_top_appl.e */
    /* Save the number of packets and data sent/received by each application in ASO (ProbVue buffer). */
    /* Verify the application name exists in the ASO (probevue buffer).  Add up the new data size to 
    old one */
    /* Function Proto types */
    int send (int s, char *uap_buf, int len, int flags);   int recv(int s, char *uap_buf, int len, 
    int flags); 
    int sendto(int s, char * uap_buf, int len, int flags, char * uap_to, int tolen);   
    int sendmsg(int s, char *uap_msg, int flags);        int recvmsg(int s, struct omsghdr *uap_msg, 
    int flags);
    int sendmmsg(int s, struct mmsghdr *uap_msgvec, unsigned int vlen, int flags);
    int recvfrom(int s, char * uap_buf, int len, int flags, char *uap_from, int *uap_fromlenaddr);
    int recvmmsg(int s, struct mmsghdr *uap_msgvec, unsigned int vlen, int flags, struct timespec *timeout);
    @@BEGIN  {
        /* Set the value to display top 'X' applications */
        set_aso_print_options($1, SORT_TYPE_DESCEND|SORT_BY_VALUE);
        appl_traffic[""]=0;delete(appl_traffic,""); /* create and delete associative
            array dummy entry.*/ 
    }
    /* Sender uses send(), sendto(), sendmsg() and sendmmsg() system calls to send the data */
    /* Save the number of packets and data sent by each application. */
    @@syscall:*:sendto:exit  {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscall:*:send:exit  {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscall:*:sendmsg:exit {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscallx:*:sendmmsg:exit  {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;    
    }
    /* Recevier uses recv(), recvto(), recvmsg() and recvmmsg() system calls to recv the data */
    /* Save the number of packets and data received by each application. */
    @@syscall:*:recv:exit  {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscall:*:recvfrom:exit  {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscall:*:recvmsg:exit   {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    @@syscallx:*:recvmmsg:exit {
        if (__rv <= 0) return;
        appl_traffic[__pname] = exists(appl_traffic, __pname) ? (appl_traffic[__pname] + __rv) :__rv;       
        appl_packets[__pname]++;   
    }
    /* Get the maximum bandwidth consumed applications in the user specified time period. */
    @@interval:*:clock:$2  {
        printf("The top %d applications generating traffic on the network in %lldmsecs....
        ..........\n", $1,$2);
        printf("Applications\t\t\tTraffic in bytes\n");    print(appl_traffic);  printf("\n");
        printf("Applications\t\t\tNumber of Packets\n");  print(appl_packets);   printf("\n");
        clear(appl_traffic);   clear(appl_packets);     
    }

    Usage of the script:

    probevue <Vue script> <Num_of_Applns > <time_interval>

    Input parameters:

    • Num_of_Applns refers to the number of applications to track (which consumes maximum bandwidth).
    • time_interval refers to the time interval in milliseconds.

    Output:

    The output shows the names of the top 10 applications that sends or receives the maximum data and packets for a specified interval of time. Also, it specifies the total data and packets sent and received by each of the top 10 applications.

    Figure 1. Top 10 applications generating traffic on the network
  2. Identify top 10 talkers and top 10 conversations that consume maximum network bandwidth on the network for a specified interval of time.

    The following ProveVue script provides a detailed analysis of the exact point where the bandwidth is getting used up. It helps to determine if the excessive usage is intended for normal business or some unexpected nodes are trying to connect to this node or web server.

    The top talkers report helps us to figure out the issues related to HTTP talkers and the top conversations report helps us to identify other network-related issues.

    Refer to the following sample ProbeVue script to identify top 10 talkers and top 10 conversations consume the maximum bandwidth.

    /* File name:  bwidth_top_talkers_convs.e */
    /* Identify the top talkers and conversations which consume maximum bandwidth */
    @@BEGIN {
            /* Set the value to display top x talkers and conversations */
            set_aso_print_options($1, SORT_TYPE_DESCEND|SORT_BY_VALUE);
    }
    /* Identify the top talkers using network probe manager */
    @@net:bpf:$2:ipv4:$3, @@net:bpf:$2:ipv6:$3  {
        __auto unsigned long long temp;
        if (__etherhdr->ether_type == ETHERTYPE_IP)  {
               if(exists(top_talkers, __ip4hdr->src_addr))
                    temp = top_talkers[__ip4hdr->src_addr] + __ip4hdr->total_len;
                else 
                    temp =__ip4hdr->total_len;
                if (__ip4hdr->src_addr  != $5)   top_talkers[__ip4hdr->src_addr] = temp;
        }
        else if (__etherhdr->ether_type == ETHERTYPE_IPV6)  {
             if(exists(top_talkers, __ip6hdr->src_addr))
                  temp = top_talkers[__ip6hdr->src_addr] + __ip6hdr->total_len;
             else 
                  temp =__ip6hdr->total_len;
              if (__ip6hdr->src_addr != $5)   top_talkers[__ip6hdr->src_addr] = temp;
        }
    }
    /* Identify top conversations using network probe manager */
    @@net:bpf:$2:ipv4:$4, @@net:bpf:$2:ipv6:$4
    {
        __auto unsigned long long temp;
        ip_addr_t i1, i2;
         if (__etherhdr->ether_type == ETHERTYPE_IP)  {
             if (__ip4hdr->src_addr == $5)  {   i1 = __ip4hdr->src_addr; i2 = __ip4hdr->dst_addr;   }
             else if (__ip4hdr->dst_addr == $5) {
                  i1 = __ip4hdr->dst_addr; i2 = __ip4hdr->src_addr;
             }  
             if(exists(top_convs, i1, i2))
                   temp = top_convs[i1][i2] + __ip4hdr->total_len;
             else 
                   temp =__ip4hdr->total_len;
        }
        else if (__etherhdr->ether_type == ETHERTYPE_IPV6)  {
            if (__ip6hdr->src_addr == $5)  {  i1 = __ip6hdr->src_addr; i2 = __ip6hdr->dst_addr;   }
            else if (__ip6hdr->dst_addr == $5)  {
                 i1 = __ip6hdr->dst_addr; i2 = __ip6hdr->src_addr;
             }  
             if (exists(top_convs, i1, i2))
                  temp = top_convs[i1][i2] + __ip6hdr->total_len;
             else 
                  temp =__ip6hdr->total_len;
        }
        top_convs[i1][i2] = temp;   
    }
    /* Provide top talkers and conversations information in the specified intervals. */
    @@interval:*:clock:$6 {
        printf("The top %d talkers and top %d conversations between two nodes on the network in  %lldmsecs.....
        ....\n", $1,$1, $6);
        printf("The top %d talkers ..........\n", $1); 
        printf("Talkers\t\t\t\t\tTraffic in bytes\n");
        print(top_talkers); printf("\n"); 
        printf("The top %d conversation between two nodes ..........\n", $1);
        printf("Conversations\t\t\t\t\tTraffic in bytes\n");   print(top_convs);     printf("\n");
        clear(top_talkers);   clear(top_convs);  //Clear the ASO arrays
    }

    Usage of the script:

            probevue <Vue script> <Num_of_top_talkers_convs> 
            <Interface > 
            <top_talks_filter> <top_convs_filter> <hostname>
            <time intervals>

    Input parameters:

    • Num_of_top_talkers_convs refers to the number of top talkers and conversations (which consumes maximum bandwidth) to be displayed.
    • Interface refers to one or more interfaces on which traffic flows (en0 or en0|en1...).
    • top_talk_filter refers to the Berkeley Packet Filter (BPF) string to track the incoming packets at this node (IP address or name).
    • top_convs_filter refers to the BPF string to track incoming and outgoing packets for this node (IP address or host name).
    • hostname refers to the host name or the IP address of this node.
    • time_interval refers to the time interval in milliseconds.

    Output:

    The output shows the IP addresses of the top 10 talkers who send maximum data to the specified node for a specified interval of time. Also, it provides information about the top 10 conversations with whom this node exchanges maximum data.

    Figure 2. Top 10 talkers and top 10 conversations
  3. Monitor the network traffic for a specified interface. This provides the amount of traffic IN and traffic OUT for a specified interface at a specified time interval.

    Administrators can monitor the ingress and egress traffic on each interface. Based on this traffic report, the administrator can take a decision to move some of the applications from the heavily loaded interfaces to the lightly loaded interfaces.

    Refer to the following sample ProbeVue script to monitor the IN and OUT traffic on each interface:

    /* File name: interface_IN_OUT_traffic.e */
    /* Monitor the incoming and outgoing traffic over  interface en1vi . */
    @@BEGIN   {
         /* Initialize the ASO */
         traffic["en1"]["Traffic IN"] =0;
    }
    /* Monitor IN and OUT traffic on interface 'en1' */
    @@net:bpf:en1:ipv4:$1, @@net:bpf:en1:ipv6:$1  {
        __auto unsigned long long temp;  
         if (__etherhdr->ether_type == ETHERTYPE_IP)  {
            if (__ip4hdr->dst_addr == $2)
                  traffic["en1"]["Traffic IN"] = traffic["en1"]["Traffic IN"] + __ip4hdr->total_len;
            else
                  traffic["en1"]["Traffic OUT"] = traffic["en1"]["Traffic OUT"] + __ip4hdr->total_len;
        }
        else if (__etherhdr->ether_type == ETHERTYPE_IPV6)  {
            if (__ip4hdr->dst_addr == $2)
                traffic["en1"]["Traffic IN"] = traffic["en1"]["Traffic IN"] + __ip6hdr->total_len;
            else
                  traffic["en1"]["Traffic OUT"] = traffic["en1"]["Traffic OUT"] + __ip6hdr->total_len;
        }
    }
    /*  Monitor IN and OUT traffic on 'en1' interface in the specified intervals. */
    @@interval:*:clock:$3   {
        printf("IN and OUT network Traffic over en1 interface in %lldmsecs ..............\n",$3);
        printf("Interface\t\tCategory\t\tTraffic in bytes\n");
        print(traffic);
        printf("\n");
        clear(traffic);
    }

    Usage of the script:

            probevue <Vue script> <In_Out_filter><hostname/IPaddress> 
            <time intervals>

    Input parameters:

    • In_Out_filter refers to the BPF string to track incoming and outgoing traffic for this node (you need to provide the IP address or host name).
    • hostname refers to the host name or the IP address of this node.
    • time_interval refers to the time interval in milliseconds.

    Output:

    The following figure shows the interface name (en1) and the IN and OUT traffic.

    Figure 3. IN and OUT network traffic over interface
  4. Identify the peak bandwidth usage time period in a day.

    You need to analyze the ingress and egress traffic for each hour in a day using the ProbeVue script and then find out the duration of maximum traffic usage for that period. Users can drill down to figure out the top conversations that contribute to the peak traffic (or highest traffic) for that period (in hour).

    Refer to the following sample ProbeVue script to identify the duration of peak bandwidth usage in a day.

    /* File name: bwidth_peak_usage.e */
    /* Identify peak bandwidth usage HRs in a day and also identify top conversations causes peak usage. */
    @@BEGIN {
        int init_strt_time, max_data, cur_data, max_flag;
        probev_timestamp_t T1, T2, start_time, end_time;
        init_strt_time = max_data = cur_data = 0; 
        /* Set the value to display top x usage HR and top x convers causing peak usage */
        set_aso_print_options($1, SORT_TYPE_DESCEND|SORT_BY_VALUE);
    }
    /* Monitor IN and OUT traffic on interface 'en1' */
    @@net:bpf:$2:ipv4:$3, @@net:bpf:$2:ipv6:$3 {
        if(!init_strt_time) {
            T1 = start_time = timestamp();
            init_strt_time = max_flag =1; 
            cur_nodes[__ip4hdr->src_addr][__ip4hdr->dst_addr] = 0;
            max_nodes[__ip4hdr->src_addr][__ip4hdr->dst_addr] = 0;
        }
        if (__etherhdr->ether_type == ETHERTYPE_IP) {
            cur_data = cur_data + __ip4hdr->total_len;
            if (max_flag)  /* Differntiate between 2 ASO buffers for current usage */
                cur_nodes[__ip4hdr->src_addr][__ip4hdr->dst_addr] += __ip4hdr->total_len;
             else
                max_nodes[__ip4hdr->src_addr][__ip4hdr->dst_addr] += __ip4hdr->total_len;    
        }
        else if (__etherhdr->ether_type == ETHERTYPE_IPV6) {
            cur_data = cur_data + __ip6hdr->total_len;
            if (max_flag) /* Differntiate between 2 ASO buffers for current usage */
                cur_nodes[__ip6hdr->src_addr][__ip6hdr->dst_addr] += __ip6hdr->total_len;
             else
                max_nodes[__ip6hdr->src_addr][__ip6hdr->dst_addr] += __ip4hdr->total_len;    
        }
    }
    /* Identify peak B.W usage HRs in a day and also identify top convs which cause peak consumption. */
    @@interval:*:clock:$4 {
        unsigned long long difftime;
        end_time = T2 = timestamp();
        peak_traffic[start_time][end_time] = (cur_data/1000);
        if (max_data < cur_data) {   /* Compare the traffic with max */
            max_data = cur_data; max_flag = 0;
        }
        else   max_flag = 1;   
        difftime = diff_time(T1, T2, MILLISECONDS);
        if (difftime >= 86400000)   { /* No of milliseconds in a day */
            printf("Start Time\t\tEnd Time\t\tTraffic in KB\n");  print(peak_traffic); printf("\n");
            printf("Top %d nodes contributing for this peak traffic\n", $1);
            printf("SRC IP\t\t\tDST IP\t\t\tTraffic in bytes\n");
            (max_flag) ? print(max_nodes) : print(cur_nodes);  exit();
        }
        start_time = timestamp(); cur_data = 0;
        (max_flag) ? clear(cur_nodes) : clear(max_nodes);
    }

    Usage of the script:

            probevue <Vue script> <Num_peak_usage> <Interface>
            <filter_str> <time intervals>

    Input parameters:

    • Num_peak_usage refers to the number of top bandwidth usage hours and top conversations that consume maximum bandwidth.
    • Interface refers to one or more interfaces (for example, en0 or en0|en1 and so on) on which traffic flows.
    • filter_str refers to the BPF filter string to track incoming and outgoing packets for this node (you need to provide the IP address or host name).
    • time_interval refers to the time interval in milliseconds.

    Output:

    The output in the following figure shows the top 10 maximum bandwidth usage hours in the day and also the top 10 conversations during peak traffic usage hour.

    Figure 4. Peak bandwidth usage

Advantages of ProbeVue over traditional tool

ProbeVue provides the following advantages over the traditional tools:

  • It takes very less time and effort to monitor network traffic and it provides the data instantly. It doesn't require post processing of the captured data performed by traditional tools.
  • It monitors the traffic continuously in the system by collecting granular details of Internet Protocol (IP), Transmission Control Protocol (TCP), User Datagram Protocol (UDP) and so on, without adversely affecting the system or network performance.
  • It gives instant powerful reports on top talkers, conversations, applications, ports, protocols, and more for a specified time interval. It helps users to solve network incidents faster, and perform better capacity planning.
  • It allows users to monitor network bandwidth and traffic usage for each interface. Based on this traffic report, users can take a decision to move some of the applications from heavily loaded interfaces to lightly loaded interfaces.
  • It allows users to monitor network traffic for a minimum interval of 100 milliseconds granularity.

Related topics

Appendix: Glossary

1. Associative array

Associative arrays are abstract data types in VUE. They are maps or look-up tables consisting of a collection of keys and their associated values. There is a one-to-one mapping between a set of keys and their values. If the instance of a key does not already exist, this adds a key or set of keys along with the associated value to the associative array. Otherwise, this replaces the associated old value with the new value.

Associative array related functions:

  1. exists()

    The exists() function checks whether the associative array has any element that corresponds to the given keys. The exists() function returns a value 1 if an element is found and else it returns 0.

    Syntax:

    For a single-dimensional associative array:

     return_value = exists (aso_name, key);

    For a multi-dimensional associative array:

     return_val = exists (aso_name, key1, key2, key3…);
  2. delete()

    The delete() function is used to remove keys and binding values from the associative array.

    Syntax:

    For a single-dimensional associative array:

     delete(aso_name, key);

    For a multi-dimensional associative array:

     delete(aso_name, key1,key2…);
  3. clear()

    The clear() function is used to clear the keys and associated values for elements of the associative array. The clear() routine is also used to reset the value of the associated array key without clearing the keys.

    Syntax:

    For a single-dimensional associative array:

     clear(aso_name);

    For a multi-dimensional associative array:

     clear(aso_name);
  4. print()

    The print() function prints the keys and the associated values for all elements or a subset of elements of the associative array by using the default print options. To override the default print options, you must use additional arguments in the print() function.

    Syntax:

    void print (aso-name, int num-of-entries, int flags, int sort_key_ind);

    The aso-name argument is mandatory. Other arguments are optional. Users can specify the following print options:

    Table 2. Associative array print options
    Print options Description Possible values Default values
    num-of-entries This specifies to print the first number of key-value pairs. Greater than zero (0).
    If 0, all entries in the associative array are displayed.
    0
    sort-type This specifies the sorting order. SORT_TYPE_ASCEND, SORT_TYPE_DESCENDSORT_TYPE_ASCEND
    sort-by This specifies to sort whether based on associative array key or value. SORT_BY_KEY, SORT_BY_VALUESORT_BY_KEY
  5. set_aso_print_options()

    The set_aso_print_options() function changes the default print options for associative arrays. The print options that can be provided by the user and their initial values are specified in Table 2. Associative array print options. This function is allowed only in the BEGIN probe.

    Syntax:

    void set_aso_print_options( int num-of-entries, int flags);

    flags values can be combination of sort-type and sort-by options mentioned earlier (in the print() function section).

2. ProbeVue time stamp

  1. timestamp()

    The timestamp() function returns the current timestamp in the probev_timestamp_t abstract data type.

    Syntax:

     probev_timestamp_t timestamp( );
  2. Timestamp data type

    A variable of type probev_timestamp_t holds the return value from the timestamp() ProbeVue function, and returns a time stamp in the internal AIX format. This variable can be later passed as a parameter to the diff_time() function that returns the difference between two time stamps.

  3. diff_time()

    The diff_time() function returns the time difference between two time stamps that were recorded using the timestamp() function. This function can return time difference in microseconds or milliseconds as specified by the format parameter.

    Syntax:

    unsigned long long diff_time( probev_timestamp_t ts1, probev_timestamp_t ts2, int format );

3. Probe managers

Probe managers are the providers of the probe points that can be instrumented by ProbeVue. Probe managers generally support a set of probe points that belong to some common domain and share some common features or attributes that distinguish them from other probe points. Probe points are useful at points where control flow changes significantly, at points of state change or at other points of significant interest.

Each probe manager has its own distinct rules for the probe specifications within the common style that must be followed for all probe specifications.

  1. System call probe manager

    The syscall probe manager supports probes at the entry and exit of well-defined and documented base AIX system calls. The syscall probe manager accepts a four-tuple probe specification in one of the following formats:

    Probe specification:

    1. syscall:<* or PID>:<system_call_name>:entry
    2. syscall:<* or PID>:<system_call_name>:exit

    '*' in second tuple means it probes for all the processes.

  2. Network probe manager

    Network probe manager tracks incoming and outgoing network packets in a system. The packet information is as interpreted by the bpf module in AIX. Accordingly, the network probe specification allows users to specify Berkeley Packet Filter (BPF) filters, similar to the tcpdump filter expression for granular tracking.

    Probe specification:

    1. Format to gather packet specific information:
       @@net:bpf:<interface1>|<interface
              2>|…..:<protocol>:<Filter>
    2. Format to gather protocol specific information:
              @@net:tcp:<event_name> 
              @@net:udp:<event_name>
  3. Interval probe manager

    The interval probe manager provides probe points that fire during a user-defined time interval. The probe points are not located in kernel or application code, but instead are based on wall clock time interval based probe events.

    The interval probe manager is useful for summarizing statistics collected over an interval of time. It accepts a four-tuple probe specification in the following format:

    Probe specification:

     @@interval:*:clock:<# milliseconds>

Downloadable resources


Comments

Sign in or register to add and subscribe to comments.

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=AIX and UNIX
ArticleID=1052912
ArticleTitle=Monitor network bandwidth usage and analyze network traffic in the IBM AIX server using ProbeVue
publish-date=11282017