Your immediate issue seems to be:

@$arr_ref is the array returned by your subroutine. Evaluated in scalar context, it yields the number of elements in the array: 101.

An array element cannot hold an array, but it can hold an array reference and your subroutine returns an array reference. If you change the line to:

You may have something more like what you were hoping for. You will certainly have some output other than newlines.

When trying to discover why my data structures are not what I want or expect, I find Data::Dumper very helpful. In the case of your program, the following might help you:

use Data::Dumper;

sub sub1{

    for $x (0 .. 100){
    $array[$x] = 0;
    }
# omit the part for generating the array;

    return \@array;
}

####################### main part
my $index;

for ($index=0; $index<2; $index++){
    $arr_ref = &sub1($index);
    $arr[$index] = @$arr_ref;

    die Dumper(\@arr);

    foreach (0 .. 100){
    print "$arr[$index][$_]\n";
    }
}
[download]

This gives the following output:

$VAR1 = [
          101
        ];
[download]

You need to get familiar with Data::Dumper to understand this output, but it is Perl code. This shows that @arr was an array of one element having the value 101. Try removing the '@' as I suggested and see what you get.

I note also that your subroutine is using the global array @array. Each time it runs it sets values in that array and returns a reference to it. As it is the same array each time, each reference is a reference to the same array. They are not independent, as you may be expecting.

There are various ways you could return a unique array form each execution of your subroutine. I would probably do something like the following:

sub sub1{

    my @array;

    for $x (0 .. 100){
        $array[$x] = 0;
    }
# omit the part for generating the array;

    return \@array;
}
[download]

Even the fragment shows some of your problems... that is, it would, with use strict; use warnings and a few print statements to see what your vars actually hold:

#!/usr/bin/perl
use 5.014;       # functional equiv to use strict; use warnings; for t
+his demo
# 985557

my ($x, @array, $index, $arr_ref, @arr);

sub sub1{
    for $x (0 .. 3){
    $array[$x] = 0;
    }
    say "\t from sub \$array[\$x]: |$array[$x]|";

# omit the part for generating the array;

    return \@array;
}

####################### main part

for ($index=0; $index<2; $index++){
    $arr_ref = &sub1($index);
    $arr[$index] = @$arr_ref;

    foreach $_ (0 .. 3){
        say "\@arr | @arr |, \$index: |$index|, \$_: |@_|";
       # print "$arr[$index][$_]\n"; 
       # Can't use string ("101") as an ARRAY ref while "strict refs" 
       # in use at 985557.pl line 24.
    }
    say "\@arr | @arr |, \$index: |$index|, \$_: |@_|";
}
say "\@arr | @arr |, \$index: |$index|, \$_: |@_|";
[download]

No, this won't bork your system; TITS -- " ...try it to see!"

And for your next step toward mastery, learning the debugger will be a help; better, in most cases than sticking in print statements, willy-nilly, as above.

There are multiple problems with this code.
Start over and explain the problem.

Update:
Well I got "yelled at" - No offense was intended.
However, I do that think that there is a valid question about what the ultimate object here is.

the generator of the array looks a little off, personally i would have used a ref, i.e. $array = [];, and done it manually, or with a loop.