I'm wondering what the better way is. :)

Rather than storing the whole file in memory, use a 2 pass solution. In the first pass, gather the locking information. In the second pass, remove the appropriate lines. Each pass will consist of just a while loop that only holds one line at a time in memory.

Re^2: Reducing memory usage while matching log entries

matt.tovey

created: 2006-02-01 11:07:53

perlmonks

• reply
• node
• thread
• author

• node
• author
• thread

prlmnks

• node
• thread
• author

I like this idea but I'm having trouble get a 2 pass solution to work nicely. In the first pass I identify which line numbers need to be removed. But then I'll need to mung that list into some convenient form to use while reading the file again in the second pass...

Tie::File looks quite handy, but since I don't want to alter the original log file, I'd have to copy it first and then reduce it, which could be a problem if disk-space is tight.

So, so far storing the whole file in a hash so that I can properly delete the lines no longer required seems like a winner.

Salva: The 'sort' idea has the problem that a given lock ID can be locked and unlocked multiple times in the file, so the sorted valued won't always be 'locking' follwed by 'unlocked'. Plus the contents of the logfile need to remain in the correct order for analysis of the remaining contents... but thanks!

Re^3: Reducing memory usage while matching log entries

duff

created: 2006-02-01 18:08:54

perlmonks

• reply
• node
• thread
• author

• node
• author
• thread

prlmnks

• node
• thread
• author

I like this idea but I'm having trouble get a 2 pass solution to work nicely. In the first pass I identify which line numbers need to be removed. But then I'll need to mung that list into some convenient form to use while reading the file again in the second pass...

I don't understand your difficulty. Pass #1 records line numbers, pass #2 writes all the lines that haven't been recorded. Here's some code based on your original but with a few tweaks:

#!/usr/bin/perl

use strict; use warnings;
sub Log;

die "Usage:     $0 \n" unless @ARGV == 1;
my $logfile = shift;

# Pass #1 : gather line numbers to be deleted.
my %locks;                      # Hash of currently open locks.
my @unlock_lines;               # lines to rid ourselves of
open(LOGFILE,$logfile) or die "Can't read $logfile - $!\n";
while () {
  Log 2, "Analysing line $.";
  next unless /Mutex\((.*?)\)::(\w+)/;
  my ($address,$action) = ($1,$2);
  if ($action eq 'locking') {
    Log 2, "Address $address locked at line $.";
    if (defined $locks{$address}) {
      Log 0, "ERROR: Address $address locked at line $., but already locked at line $locks{$address}.";
    }
    $locks{$address} = $.;
  }

  if ($action eq 'unlocked') {
    Log 2, "Address $address unlocked at line $.";
    unless (defined $locks{$address}) {
       Log 0, "ERROR: Address $address not locked, but unlocked at line $..";
    } else {
        push @unlock_lines, $., delete $locks{$address};
    }
  }
}
close LOGFILE;

# Sort the lines numbers that we've accumulated because we put them in
# unordered. This allows us to make just one more pass through the file
# to remove the lines.
@unlock_lines = sort { $a <=> $b } @unlock_lines;

# Pass #2: output all but the lines we're not interested in.
my $rmline = shift @unlock_lines;
open(LOGFILE,$logfile) or die "Can't read $logfile - $!\n";
while () {
   if (defined $rmline && $. == $rmline) {
      $rmline = shift @unlock_lines;
      next;
   }
   print;
}
close LOGFILE;

[duff]

Re^4: Reducing memory usage while matching log entries

matt.tovey

created: 2006-02-02 04:00:13

perlmonks

• reply
• node
• thread
• author

• node
• author
• thread

prlmnks

• node
• thread
• author

I like this idea but I'm having trouble get a 2 pass solution to work nicely...

I don't understand your difficulty...

Sorry, I had to leave work about the time of my last message yesterday (well, actually 10 minutes _before_ my last message!), but didn't want to disappear without writing back. And I'm not good at coding under stress (and not fantastic the rest of the time either!).

Anyway, thanks for taking the time to write out the code there. Strangely enough, I tried it this morning, and the memory usage of this is actually higher than the original, at least as Linux measures it! I'm processing a 65MB test file - after the first pass the script is consuming 100MB of memory, and after the sort then 200MB!
With this test file, @unlock_lines ends up with 800000 entries, but still I was surprised. My original script used (RSS & VSZ) 160MB, and using a hash to store the file in memory (so as to properly free the deleted lines) brings it down to 110MB...

Thanks also for '$.' - I didn't know about that one!

Re^3: Reducing memory usage while matching log entries

salva

created: 2006-02-02 05:55:59

perlmonks

• reply
• node
• thread
• author

• node
• author
• thread

prlmnks

• node
• thread
• author

The 'sort' idea has the problem that a given lock ID can be locked and unlocked multiple times in the file, so the sorted valued won't always be 'locking' follwed by 'unlocked'.

That shouldn't be a problem as long as you use an stable sort implementation or alternatively the line number or a timestamp as the secondary sorting key.

Yeah, without sample data it's hard to give advice. But the correct way to remove an element from a hash is with delete, not by assigning an empty string. And you're doing something really weird with @lines; if you get to line 100,000 it's going to allocate a 100,000 element array. Considering it's probably sparse you should use a hash for that as well.

If you're still running into memory issues you might look at using a tied hash (DB_File or BerkeleyDB) or even DBD::SQLite to store stuff you've seen somewhere easily retrieved. Those wouldn't keep much of anything in memory but fetching to see the state of a given address should still be pretty quick.

Re^2: Reducing memory usage while matching log entries

matt.tovey

created: 2006-02-01 10:49:50

perlmonks

• reply
• node
• thread
• author

• node
• author
• thread

prlmnks

• node
• thread
• author

And you're doing something really weird with @lines; if you get to line 100,000 it's going to allocate a 100,000 element array. Considering it's probably sparse you should use a hash for that as well.

Yes, that's the file being held in memory. :(

I just tried putting that into a hash (also using 'delete' now - thanks!). It runs only slightly slower, and consumes quite a bit less memory, so success there!

Take a look at Tie::File, this allows you to treat the file as an array without loading the entire file into memory.

After that, assuming nested locks are not allowed, every lock entry should be followed by an unlock one, something very easy to parse!

I don't understand why you are using the @lines array at all, and without that your memory requirements go way down. The logic would be something like:

• %locks records currently open locks, with the key being the mutex address and the value being the input file line number where the lock was acquired
• if a 'locking' line is seen for a locked mutex, report it and overwrite the %locks entry with the newer lock
• if an 'unlocked' line is seen for a locked mutex, remove the %locks entry
• if an 'unlocked' line is seen for an unlocked mutex, report it
• when the input file is exhausted, report all remaining entries in %locks as "never unlocked"

Your existing code is close to that: remove the references to @lines; replace the definition of $count with:

  my $count = $.;  # input line number

  delete $locks{$address};

for (sort keys %locks) {
  Log 0, "ERROR: address $_ locked at line $locks{$_} but never unlocked.";
}

Hope this helps,

Hugo

use strict;
my %locks;

while (chomp(my $line = )) {
	next unless ($line =~ /Mutex(.*)::(.*)/);
	my ($mutex,$action) = ($1,$2);

	if ($action eq 'locking') {
		if ($locks{$mutex}) {
			printf ("Mutex %s already locked on line %d, locked again on line %d\n",
				$mutex, $locks{$mutex}, $.);
		} else {
			$locks{$mutex} = $.;
		}
	} elsif ($action eq 'unlocked') {
		if ($locks{$mutex}) {
			delete $locks{$mutex};
		} else {
			printf ("Mutex %s unlocked on line %d, but wasn't locked.\n",
				$mutex, $.);
		}
	}
}

foreach my $mutex (keys %locks) {
	printf ("Mutex %s locked on line %d, nut wasn't unlocked\n",
		$mutex, $locks{$mutex});
}