Takamoto:

To test your code, I added this to the end:

sub tprint {
    my $t = time;
    print "$t: ", shift, "\n";
}

sub getResultsAPI {
    my ($name, $doze_time) = @_;
    tprint "API_$name: dozing for ${doze_time}s";
    sleep $doze_time;
    tprint "API_$name: done";
}


sub getResultsAPI_1 { getResultsAPI(1, 12) }
sub getResultsAPI_2 { getResultsAPI(2, 22) }
sub getResultsAPI_3 { getResultsAPI(3, 16) }
sub getResultsAPI_4 { getResultsAPI(4, 5) }
sub getResultsAPI_5 { getResultsAPI(5, 11) }
sub getResultsAPI_6 { getResultsAPI(6, 7) }
[download]

And it seemed to do what you'd expect:

$ perl pm_11107400.pl
1570989189: API_1: dozing for 12s
1570989189: API_2: dozing for 22s
1570989189: API_3: dozing for 16s
1570989189: API_4: dozing for 5s
1570989189: API_5: dozing for 11s
1570989194: API_4: done
1570989200: API_5: done
1570989201: API_1: done
1570989205: API_3: done
1570989211: API_2: done
[download]

Of course, if your APIs contend with each other for resources (such as hitting the hard drive a lot), you may not save much time. If they run well in parallel as the simple sleep timers do in the case I tried, you can save much more. Make sure you look at what your different APIs do to see if they conflict with each other. Bundling IO-heavy operations with CPU-heavy operations tends to work well to save you time. Similarly, you can *lose* time if you have processes always contending for the same resources.

Note that you have a minor bug, though, in that you never run API_6. I'm assuming the bug was introduced by your simplification of the test code.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

Are forks needed for this, or could you be making your API requests using a non-blocking user agent?

Forks have their own overhead, and when you make an HTTP request against an API, most of your time is spent just sitting around waiting for the response -- you're not CPU bound. If this describes your situation, have a look at Mojo::UserAgent, Mojo::IOLoop, and Mojo::Promise. There are other options: AnyEvent::UserAgent, for example, but Mojo::UserAgent makes such tidy work of the problem, it's a really nice option.

Of course I don't know what type of API you're hitting. Hopefully this suggestion is useful in your case. Example:

my @promises = map {$ua->get_p($_)} @api_points;

Mojo::Promise->all(@promises)->then(sub {
    my (@results) = @_;

    print Dumper $_->[0]->{'result'}->json
        foreach @results;
});
[download]

If you have six @api_points this will make six GET requests in rapid fire and then process the results when they all return. There's a little code that I didn't show that surrounds this; using Mojo::UserAgent, getting a $ua object, kicking off the event loop if it hasn't started, that sort of thing. But it's all documented in the links above.

See also. Regards, Karl