You can avoid sorting altogether. And you should.

As your records are fixed length, (barring the first and last?), there is a direct arithmetic relationship between the address of a record and its position in the file. So, use a big scalar--the most efficient form of Perl memory--and write records directly in-place. Or even directly to disk and avoid large memory usage.

As for tracking whether all the records have been written, the same arithmetic properties can be used to reduce the absence/presence of a given record, to a single bit in a bit-string. With 46-byte records, 200 MB reduces to a 1/2 MB bit-string for tracking. And this is easily and quickly checked for completion by a simple:

if( $tracking =~ m[[^\0]] ) { 
     ##    ...
}
[download]

I know you are using threading. If the records of an individual file are being produced by different threads, then some care will need to be taken to ensure these large scalars are not replicate per thread. Perhaps the simplest way would be to use a Queue to a single writing and tracking thread.

In my example all S-Records have the same length. But this has not to be the case. Each S3-Record has a field which indicates the number of bytes for address, data and checksum.

Can you explain me the tracking in more detail please. Because I do not understand your idea completely. You mean that I have a bit-string in memory. And I initialise it with 0 and if I find a record then I put a 1 at this position. At the end I have to check if all positions in the bit-string are set to 1. Is this correct?

But this has not to be the case.

Unless all the records in a given file (or, at least in each given portion of a file; though that does complicate things considerably), then the idea doesn't work. But if they are, then it converts an O(n log n) process to O(n), which will have a far more profound effect upon your processing performance than specific sort implementations ever will.

The fundamental requirement for this to work is a simple arithmetic calculation to convert the address of a record to its position in the file. I envisioned this being something like:

my $filePos = ( $recAddr - $firstRecAddr ) * ( $recLen + 1 ) + $lenOfH
+eader;
[download]

This would then allow you to seek directly to the appropriate file (or ramfile) position, and write the record in its final position directly. A similar calculation can be used to address the appropriate bit in the tracking bit-vector.

You mean that I have a bit-string in memory. And I initialise it with 0 and if I find a record then I put a 1 at this position. At the end I have to check if all positions in the bit-string are set to 1. Is this correct?

You have the general idea, but I inverted the state of the bits. Ie.

I envisaged initialising the all the bits to 1: my $tracker = chr(255) x ( $noOfRecords / 8 );

Then unsetting the bits as the records are written: vec( $tracking, 1, $recNo ) = 0;

Then testing for completion by search the tracking vector for non-zero bytes: if( $tracking =~ m[[^\0]] ) {...

But doing it the other way, initialising to 0, setting bits and then searching for non-0xff bytes is the same.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy

For ease of use, I would just read the whole file into an array and then sort that array by address (which should be identical to sorting it by the elements directly, judging from the format, except for the last row).

Otherwise, if memory becomes a real issue, I would try to reconstruct the memory as a scalar, using substr to write the payload data into the correct location. If the string is too short for the current location, expand the string appropriately.

I tried your solution. Here is my code which seems to work.

#!/usr/bin/perl

use strict;
use warnings;

my $in_file_name = "D:/temp.s3";
my $data = "";  

&extractDataFromSrecFile($in_file_name, \$data);
print($data,"\n");

sub extractDataFromSrecFile
{
    my ($file_name, $ref_data) = @_;
    my @in_data;


    # read file into memory
    open(my $fh, "<", $file_name) || die "Could not open \"$file_name\
+"";
        
    while( my $srec = <$fh> )
    {        
        chomp($srec);

        my $id = substr($srec,0,2);
        my $address = substr($srec, 4, 8);
        
        if( ($id eq "S3") &&
            ($address ne "FC000000") )
        {
            push(@in_data, $srec);
        }
    }

    close( $fh );

    
    # store sorted data and check if it is complete
    $$ref_data = "";
    my $next_address = 0xFC000018; # start address
    for( sort{ hex(substr($a, 4, 8)) <=> hex(substr($b, 4, 8)) } @in_d
+ata )
    {
        my $srec = $_;
        my $address = hex(substr($srec, 4, 8));
        my $nb_data_bytes = hex(substr($srec,2,2)) - 4 - 1;

        # completeness check
        if( $address != $next_address )
        {
            $$ref_data = "";
            print "ERROR: S3-Record with address " . sprintf("%08X", $
+next_address) . " is missing in input file!\n";
            return; 
        }
        
        $$ref_data .= substr($srec, 12, ($nb_data_bytes * 2));

        $next_address = $address + $nb_data_bytes;
    }
}
[download]

Because I want to learn feel free to improve the code and give hints what I could do better.

Thank you

Dirk

Because I want to learn feel free to improve the code and give hints what I could do better.

Use printf instead of print and sprintf. This:

print "ERROR: S3-Record with address " . sprintf("%08X", $next_address
+) . " is missing in input file!\n";
[download]

is shorter (and perhaps clearer) as this:

printf "ERROR: S3-Record with address %08X is missing in input file!\n
+", $next_address;
[download]

This is so weird. I was just working with S-record files yesterday. Here's the start of my S-record parser.

#!/usr/bin/perl
use strict;
use warnings;

process( $ARGV[0] );

sub process
{
    my $file = shift;

    # First, grab the contents of the firmware hex (S19) file
    my $contents = slurp( $file );

    my @lines = split /\n/, $contents;

    my %data;
    for my $line ( @lines )
    {
        next if $line =~ /^S0/; # skip comments
        next if $line =~ /^S7/; # skip 32-bit termination records
        next if $line =~ /^S8/; # skip 24-bit termination records
        next if $line =~ /^S9/; # skop 16-bit termination records

        # We could do all sorts of things to bulletproof this but it w
+orks
        my ( $rectype, $length, $address, $data, $checksum ) =
            $line =~ /
                ^               # start of line
                (S[123])        # S1, S2, or S3 record
                ([0-9A-F]{2})   # record length including the address 
+and checksum
                ([0-9A-F]{8})   # address
                ([0-9A-F]+)     # data or payload
                ([0-9A-F]{2})   # checksum
                \r?$            # end of line
            /x;

        my @bytes = unpack "(A2)*", $data;
        my $numbytes = scalar @bytes;
        my $nextaddr = sprintf( "%X", hex( $address ) + $numbytes );

        $data{ $address } = {
            rectype     => $rectype,
            length      => $length,
            data        => $data,
            checksum    => $checksum,
            bytes       => [ @bytes ],
            numbytes    => $numbytes,
            nextaddr    => $nextaddr,
        };
    }

    my @ordered = sort { hex( $a ) <=> hex( $b ) } keys %data;

    for my $recno ( 0 .. $#ordered )
    {
        my $curraddr = $ordered[ $recno ];

        if ( ! exists $data{ $curraddr } )
        {
            print "$curraddr   <no data found>\n";
            next;
        }

        my $rec = $data{ $curraddr };

        my $nextrec = $ordered[ $recno + 1 ];
        print "$rec->{rectype} $curraddr $rec->{length} $rec->{data} $
+rec->{checksum}\n";
        if ( defined $nextrec && $nextrec ne $rec->{nextaddr} )
        {
            print "           <no data until $nextrec>\n";
        }
    }
}

sub slurp
{
    my $file = shift;
    my $text = do { local( @ARGV, $/ ) = $file ; <> };
    return $text;
}
[download]

Good solution. You chose the way to store everything in a hash. I like this way. But of course you load the complete file into memory. But if you have enough memory I think it is a very good way.

UPDATE:

Untested: But I think the data is hex-ascii. So I think that the unpack command should use '(H2)*' instead of '(A2)*'.

No. See Intel HEX in perlpacktut for examples. (Also: See code by other respondents! Update: Actually, now I look, I don't see any such examples.)

Untested: But I think the data is hex-ascii. So I think that the unpack command should use '(H2)*' instead of '(A2)*'.

Only if you want it in binary. For my purposes, I prefer to keep it in hex until I get one of two specific addresses and then convert their data. This allows me to view the data without corrupting my terminal settings.

my prev_address=0;
for my $address (sort keys %data){
...
[download]

Now my question is how to do it. Is the best way to go once through the input file, sort it by address and then do it as before? But I think that this will have a slow performance. Here you see only a small example. The file can be really huge (e.g. 200 MB)

One of the advantages is that sort(1) doesn't easily run out of memory (although, with modern computers, 200MB should be ok) - it will resort to using temp files if it doesn't have enough memory to do it all in-memory.

Is there also a perl sort command for files? I've seen that there exists File::Sort. What do you think of this? I want that the script is independent of OS and independent of the availability of an external command.

sort -k 1.5 s3.txt | grep S3 > s3_sorted_by_addr.txt
[download]