I find really light weight OO cleans up globals something wonderful. Consider:

use strict;
use warnings;

my $obj = bless {global1 => 0, global2 => 3};

$obj->setThree (6);
$obj->doSomething ();
print $obj->{four};


sub setThree {
    my ($self, $three) = @_;
    $self->{three} = $three;
}


sub doSomething {
    my ($self) = @_;
    $self->{four} = $self->{three} + $self->{global2};
}
[download]

Prints:

9
[download]

So the cost is a bless to create $obj then calling "methods" on $obj rather than directly calling the subs and having to access stuff through $self inside the subs.

The real question is, does it buy you anything? Well, for the first cut when there were only a couple of variables and the whole thing was only a few dozen lines long, nope, it buys you nothing at all.

For the second cut where you are adding a few more globals, you don't have to scroll to the top of the file to add globals - not really a win yet. But at least it's likely the subs dealing with the new "globals" are close together and the documentation describing them can be close by too, so there is some real benefit.

But with the third round where you could really do with refactoring the code and generate a real class, guess what - you've already done most of the work!

For anything that is likely to grow I find using light weight OO from the start makes it easier to evolve the code over time. The payback isn't on day one, but by a modest chunk into the project the scale tips and the up front work becomes worth while.