As long as you don't try to read the whole file into memory at once, you will be fine.

Just read a line at a time and open a new outputfile whenever you see that the size is too big and the current line starts with "100". Something like this:
while (defined $line = <$inputFileHandle>)

while ($line = <$inputFileHandle>)
{
  if ($sizeSoFar > 1e9 and $line =~ /^100/)
  {
    $outputFileName++;
    open $outputFileHandle, '>', $outputFileName or die "Cannot open $
+outputFilename for writing: $!\n";
    $sizeSoFar = 0;
  }
  print $outputFilehandle $line;
  $sizeSoFar += length($line);
}
[download]

while (defined $line = <$inputFileHandle>)
[download]

Because the  = operator has higher precedence than the defined operator you need to either enclose the assignment in parentheses:

while (defined( $line = <$inputFileHandle> ))

Or because perl does the defined test by default then just omit it and perl will do the right thing:

while ($line = <$inputFileHandle>)

#!/usr/bin/perl
use constant DAILY_RUN => 1024 * 1024 * 1000;
use strict;
use warnings;

my $file = $ARGV[0] or die "Usage: $0 <input_file>";
open(my $fh, '<', $file) or die "Unable to open '$file' for reading: $
+!";

my $cnt = 1;
my $out_file = "$file.$cnt";

# Will clobber an existing file by this name (fix if important)
open(my $out_fh, '>', $out_file) or die "Unable to open '$out_file' fo
+r writing: $!";

while (<$fh>) {
    if (-s $out_file > DAILY_RUN && /^100/) {
        ++$cnt;
        $out_file = "$file.$cnt";
        open($out_fh, '>', $out_file) or die "Unable to open '$out_fil
+e' for writing: $!";
    }
    print $out_fh $_;
}
[download]

Now it looks like your lines are fixed length so one optimization may be not to check after every write how big the file is but to wait until you have written enough to be at least 1 GB and set a flag to pay attention to the start of a 100 record. Additionally, this code writes at least 1GB and then starts a new file as soon as a 100 record is encountered - you may want to keep it under 1GB. Again, you are in a better position to address these than I am. Finally, it may be possible to process the record sets as a whole rather than a line at a time by setting $/ = "\n100"; That is an advanced technique that you can read about in perlvar. It complicates the code but it is presumably more efficient (less disk read/writes)

That worked perfectly Limbic~Region Thanks for your help... I hope I don't have to use it, as that means my initial ETL had crashed. This little exercise was interesting.. I did alot of research and had many interesting results (unsuccessful) from my own scripts. I'm going to try and adjust your script to see if I can add a header and footer.

The GNU utility split can split on line counts, which seems to be very close to what you want - just divide by the number of chars per line (+1 for the line feed or +2 if using carriage return as well). See the split man page, option -l.

Update: Sorry - missed the criteria that each first line must begin with 100.

Untested and needs tidying:

use strict;
use warnings;

my $MAX_FILE_SIZE = 10_000_000_000;

my $num = 0;
my $next_outfile = sub {
    open my $OUT, '>', 'file_' . (++$num) or die $!;
    return $OUT;
}

my $OUTPUT;
my $curr_size;
my $process_chunk = sub {
    my $chunk = shift;
    if(not defined $curr_size 
        or $curr_size + length($chunk) > $MAX_FILE_SIZE) {
        $OUTPUT = $next_outfile->();
        $curr_size = 0;
    }
    $curr_size += length($chunk);
    print $OUTPUT $chunk;
};

my $chunk;
while(my $line = <INPUT>) {
    if($line =~ /^100/) {
        $process_chunk->($chunk);
        $chunk = '';
    }
    $chunk .= $line;
}
[download]

Reading guide: code is best understood by starting with the while loop at the bottom.

mzedeler,
missed the criteria that each first line must begin with 100

I think you also missed the criteria about splitting a 10GB into 1 GB chunks. Also, in the OP's own words

"I’m not a Perl guy so excuses my ignorance… I’m the database ETL guy. Not sure if perl is the right choice either."

I think your code refs and closures are cool but I am not sure they will be of much benefit to the OP if they need to tweak anything. I don't want this to come off as an admonishment, I am just doubtful that the OP could take your code and run with it.

Cheers - L~R