my %clusters = (
    cluster1 => [ 'server1', 'server2' ],
    cluster2 => [ 'server3', 'server4' ],
);

my %averages;
while ( my ($cluster, $machines) = each %clusters ) {
    my @values;
    foreach my $machine ( @$machines ) {
        push @values, # Whatever you do here for $machine
    }
    $averages{ $cluster } = # Whatever you do here with @values
}
[download]

use strict;    # always use this
use warnings;  # .. and this
my %servers = (  # store the server cpu values by cluster
  cluster1 => {
    server1 => 10,
    server2 => 20,
  },
  cluster2 => {
    server3 => 15,
    server4 => 5,
  },
);
foreach my $clusterName ( keys %servers ){
  my $servers = $servers{$clusterName};
  next unless scalar values %$servers;   # avoid div by zero
  my $sum = 0;
  $sum += $_ for values %$servers;
  printf "%s cpu avg is %.2d%%\n", $clusterName, 100*$sum/(scalar valu
+es %$servers);
}
[download]

How about structuring your data like this,

%usage_for = (
  'cluster1' => {
    'server1' => 5,
    'server2' => 10,
  },
  'cluster2' => {
    'server3' => 20,
    'server4' => 30,
  }
);

foreach my $cluster (keys %usage_for) {
  my $usage;
  print "Cluster Servers\n";
  foreach my $server (keys %{$usage_for{$cluster}}) {

    $usage += $usage_for{$cluster}{$server};
    print "\t$server => " . $usage_for{$cluster}{$server} . "\n"; 
  }
  print "Usage for $cluster => " . $usage . "%\n";
}
[download]

(Update:  Having now seen them, I actually like dragonchild and davidrw's answers, above (as well as Herkum's, below), even better, because they redesigned the data structure to be more natural.  So my answer, though closer to your original code, is not the one I would choose.)

#!/usr/bin/perl -w
                                                                      
+          
use strict;
use warnings;
                                                                      
+          
                                                                      
+          
my %servers = (
    'server1' => 'cluster1',
    'server2' => 'cluster1',
    'server3' => 'cluster2',
    'server4' => 'cluster2'
);
                                                                      
+          
my %values = (
    'server1' => 20.00,
    'server2' => 10.00,
    'server3' =>  5.00,
    'server4' => 15.00,
);
                                                                      
+          
my %cluster_count;
                                                                      
+          
#
# Here is where you fill in values, such that...
#
#     $values{'server1'} = <cpu info for server1>
#     $values{'server2'} = <cpu info for server2>
#     ... etc ...
#
# But, I'm going to cheat and do ...
                                                                      
+          
%values = (
    'server1' => 20.00,
    'server2' => 10.00,
    'server3' =>  5.00,
    'server4' => 15.00,
);
                                                                      
+          
my %results_by_cluster;
                                                                      
+          
#
# Calculate results by cluster, and save cluster counts (this is
# necessary for the calculation of averages).
#
foreach my $srvr (keys (%servers)) {
    my $cluster = $servers{$srvr};
    ++$cluster_count{$cluster};
    $results_by_cluster{$cluster} += $values{$srvr};
}
                                                                      
+          
#
# Display results
#
foreach my $cluster (qw(cluster1 cluster2)) {
    my $avg = $results_by_cluster{$cluster} / $cluster_count{$cluster}
+;
    printf "%20.20s average is:  %f\n", $cluster, $avg;
}
[download]

This seems like a rather poorly defined problem. Let me try to reconstruct what you are trying to do:

• You have a number of clusters, for which you want to report total (or possibly average?) CPU usage %.
• Each cluster has a number of servers, whose names you need to keep track of so you can contact them for CPU info.

So one way to address this problem is to have a hash keyed by server name, and each hash entry's value is a reference to an array of values (server_name, CPU utilization).

Try something like this (untested) code to accumulate total CPU usage:

use strict;
use warnings;
my %server_hash = ( 
  'server1' => ['cluster1',0], 
  'server2' => ['cluster1',0], 
  'server3' => ['cluster2',0], 
  'server4' => ['cluster2',0] );

my %cluster_totals = ();
foreach my $this_server(keys %server_hash) {
  $server_hash{$this_server}->[1] = getCPUUtilization($this_server);
  $cluster_totals{$server_hash{$this_server}->[0]} += $server_hash{$th
+is_server}->[1];
}
foreach (keys %cluster_totals) {
  print "Cluster: $_ \t $cluster_totals{$_}\n";
}
[download]

Granted, I'm using an extra hash where I probably don't need to, and this solution is off-the-cuff. But it might provide you with a starting point. The nice thing about a hash of array references is that it is extensible when you need to store yet another attribute of the server.

#!/usr/bin/perl -T
use strict;
use diagnostics;

# --

sub get_cpu {
    my $servername    = shift;
    my %cpu    = (
        server1 => 10,
        server2 => 20,
        server3 => 5,
        server4 => 15,
    );
    return $cpu{$servername};
};

# --

my %servers    = (
    server1 => 'cluster1',
    server2 => 'cluster1',
    server3 => 'cluster2',
    server4 => 'cluster2',
);

my %clusters;
foreach my $servername (keys %servers) {
    $clusters{$servers{$servername}}    += get_cpu($servername);
};

print "$_:\t".($clusters{$_}/2)."\n" foreach sort keys %clusters;
[download]

Or skip the hardcoded server count assumption.

my %clustertotal;
my %clustercount;
foreach my $servername (keys %servers) {
    $clustertotal{$servers{$servername}}    += get_cpu($servername);
    $clustercount{$servers{$servername}}++;
};

print "$_:\t".($clustertotal{$_}/$clustercount{$_})."\n" foreach sort 
+keys %clusters;
[download]