You are connecting to both stdin & stdout, but never processing stdout. Consequently, if the child process produces any output, it will eventually fill the pipe that you are not reading and the OS will block the child from writing anymore until you do something in the parent to reduce the content of the pipe.

The number of iterations it will run will depend upon the amount of output produced by the child. Ie. How quickly it fills the pipe buffer. Eg. In the following which just echos the 'some command's it reads, the iteration count gets to 83 before it blocks.

#! perl -slw
use strict;
use IPC::Open2;

$|++;

my $pid = open2 \*READ, \*WRITE, 'perl -wne "$|++; chomp; print"';

my $read = '';
for ( 1 .. 1e4 ) {
    Win32::Sleep( 10 );
    printf "\r$_\tGot'$read'\t";
    print WRITE 'some command';
}
__END__
c:\test>junk
Name "main::READ" used only once: possible typo at c:\test\junk.pl lin
+e 7.
83      Got''   Terminating on signal SIGINT(2)
[download]

83 * 13 = 1079, suggesting roughly a 1k buffer.

Reduce the output to a single char:

#! perl -slw
use strict;
use IPC::Open2;

$|++;

my $pid = open2 \*READ, \*WRITE, 'perl -wne "$|++; chomp; print 1"';

my $read = '';
for ( 1 .. 1e4 ) {
    Win32::Sleep( 10 );
    printf "\r$_\tGot'$read'\t";
    print WRITE 'some command';
}
__END__
c:\test>junk
Name "main::READ" used only once: possible typo at c:\test\junk.pl lin
+e 7.
553     Got''   Terminating on signal SIGINT(2)
[download]

This time the iteration count gets to 553, which means that the size of the buffer is a little more complicated.

But if you process the output from the child within the parent's loop:

#! perl -slw
use strict;
use IPC::Open2;

$|++;

my $pid = open2 \*READ, \*WRITE, 'perl -wne "$|++; chomp; print 1"';

my $read = '';
for ( 1 .. 1e6 ) {
#    Win32::Sleep( 10 );
    printf "\r$_\tGot'$read'\t";
    print WRITE 'some command';
    sysread( READ, $read, 1024 );
}
__END__
c:\test>junk
1000000 Got'1'
[download]

Now the loop happily runs for as long as you care to leave it running. The OS is simply protecting you from yourself, by preventing you from consuming all your memory by filling a pipe with output that you are never processing.

Note: I used the non-blocking sysread to process the output as the child process is never producing newlines, so <READ> or read would block.