This document discusses parallel and concurrent features in Perl 6. It covers implicit parallelism enabled by operators like hyper operators and junctions. Explicit parallelism using feeds, channels, and promises is also discussed. Promises allow asynchronous and parallel execution, and examples are given using Promise.in to run code in threads and the sleep sort algorithm. Further parallel constructs like schedulers, suppliers, signals, threads, atomic operations, locks and semaphores are also mentioned for additional exploration.

1. Perl 6 for
Concurrency and
Parallel Computing

2. or

3. Parallel Features
of Perl 6

4. The Parallel
Features
of the Perl Six

5. Parallel Futures
of Perl 6

6. Foreword

7. Interviews for
Pragmatic Perl
in 2013–2015

9. What is the most important
feature of the programming
languages in the future?
Q:

10. I don’t knowA:
No idea (2 answers)

11. There’s no good answerA:
No idea (2 answers)

12. Natural-like languageA:
Syntax features (1/3)

13. MinimalismA:
Syntax features (2/3)

14. ExtendabilityA:
Syntax features (3/3)

15. Flexible type castingA:
Object system (1/3)

16. RobustnessA:
Object system (2/3)

17. Built-in introspectionA:
Object system (3/3)

18. JVM supportA:
Environment (1/4)

19. Execution in a browserA:
Environment (2/4)

20. Language inter-compatibilityA:
Environment (3/4)

21. EmbeddingA:
Environment (4/4)

22. CommunityA:
Humanity (1/8)

23. HumanismA:
Humanity (2/8)

24. Open sourceA:
Humanity (3/8)

25. PragmatismA:
Humanity (4/8)

26. Mind control (sic!)A:
Humanity (5/8)

27. Expressing things easilyA:
Humanity (6/8)

28. Domain orientedA:
Humanity (7/8)

29. UnobtrusivenessA:
Humanity (8/8)

30. Number 1 answer
Parallelism

31. ParallelismA:
Parallelism (1/12)

32. Working with parallel
resources
A:
Parallelism (2/12)

33. ParallelismA:
Parallelism (3/12)

34. Good paralleling modelA:
Parallelism (4/12)

35. Intuitive coroutines and
multi-core support
A:
Parallelism (5/12)

36. ParallelismA:
Parallelism (6/12)

37. Safe operation parallelismA:
Parallelism (7/12)

38. Built-in threadingA:
Parallelism (8/12)

39. Qualitative abstract threadingA:
Parallelism (9/12)

40. ParallelismA:
Parallelism (10/12)

41. Good parallelismA:
Parallelism (11/12)

42. Multi-taskingA:
Parallelism (12/12)

43. Back to Perl 6

44. The idea is
keeping things
transparent

45. A Perl 6 user
simply uses
concurrency

46. A Perl 6 compiler
makes it possible

47. A Perl 6 compiler
makes it possible

48. The Perl 6 compiler
makes it possible

49. Running examples
with Rakudo Star

50. Running examples
with Rakudo Star
on MoarVM

51. Two kinds
of parallel features

52. Roughly,
1) implicit
2) explicit

53. Operators
at a glance

54. 1.
Hyperops

55. A hyper operator
is a
meta operator

56. +
operator

57. +=
meta operator

58. >>+<<
hyper operator

59. »+«
hyper operator

60. >>+
hyper operator

61. »+
hyper operator

62. >>+>>
hyper operator

63. <<+<<
hyper operator

64. «+«
hyper operator

66. <<+>>
hyper operator

67. «+»
hyper operator

68. <<<>>
hyper operator

69. «<»
hyper operator

70. @c = @a >>+<< @b

71. @c = @a >>+<< @b
@c[0] = @a[0] + @b[0];

72. @c = @a >>+<< @b
@c[0] = @a[0] + @b[0];
@c[1] = @a[1] + @b[1];

73. @c = @a >>+<< @b
@c[0] = @a[0] + @b[0];
@c[1] = @a[1] + @b[1];
@c[2] = @a[2] + @b[2];

74. @c = @a >>+>> 1

75. @c = @a >>+>> 1
@c[0] = @a[0] + 1;

76. @c = @a >>+>> 1
@c[0] = @a[0] + 1;
@c[1] = @a[1] + 1;

77. @c = @a >>+>> 1
@c[0] = @a[0] + 1;
@c[1] = @a[1] + 1;
@c[2] = @a[2] + 1;

78. 2.
Junctions

79. Or
Quantum
Superpositions

80. Many values as one

81. my $j = 1 | 2 | 3 | 5;

82. my $j = 1 | 2 | 3 | 5;
say 1 if 3 == $j;

83. my $j = 1 | 2 | 3 | 5;
say 1 if 3 == $j;

84. my $j = 1 | 2 | 3 | 5;
say 1 if 3 == $j;

85. my $j = 1 | 2 | 3 | 5;
say 1 if 3 == $j;
}

86. my $j = 1 | 2 | 3 | 5;
say 1 if 3 == $j;
}1

87. 3.
Feeds

88. my @a = 1..10;

89. my @a = 1..10;
@a ==> grep {$_ mod 2};

90. my @a = 1..10;
@a ==> grep {$_ mod 2};
!
1 3 5 7 9

91. my @a = 1..10;
@a
==> grep {$_ mod 2}
==> map {$_ ** 2};

92. my @a = 1..10;
@a
==> grep {$_ mod 2}
==> map {$_ ** 2};
!
1 9 25 49 81

94. 4.
Channels

95. my $c = Channel.new;

96. my $c = Channel.new;
$c.send(42);

97. my $c = Channel.new;
$c.send(42);
say $c.receive;
!
42

98. my $ch = Channel.new;

99. my $ch = Channel.new;
for <1 3 5 7 9> {
$ch.send($_);
}

100. my $ch = Channel.new;
for <1 3 5 7 9> {
$ch.send($_);
}
while $ch.poll -> $x {
say $x;
}

101. 5.
Promises

102. my $p = Promise.new;

103. my $p = Promise.new;
say $p.status;
Planned

104. my $p = Promise.new;
$p.keep;

105. my $p = Promise.new;
$p.keep;
say $p.status;
!
Kept

106. my $p = Promise.new;
$p.break;

107. my $p = Promise.new;
$p.break;
say $p.status;
!
Broken

108. Factory methods

109. start

110. my $p = start {42};

111. my $p = start {42};
say $p.WHAT;
(Promise)

112. my $p1 = start {sleep 2};

113. my $p1 = start {sleep 2};
my $p2 = start {sleep 2};

114. my $p1 = start {sleep 2};
say $p1.status;
my $p2 = start {sleep 2};
say $p2.status;

115. my $p1 = start {sleep 2};
say $p1.status;
my $p2 = start {sleep 2};
say $p2.status;
!
Planned
Planned

116. my $p1 = start {sleep 2};
my $p2 = start {sleep 2};
sleep 3;

117. my $p1 = start {sleep 2};
my $p2 = start {sleep 2};
sleep 3;
say $p1.status;
say $p2.status;

118. my $p1 = start {sleep 2};
my $p2 = start {sleep 2};
sleep 3;
say $p1.status
say $p2.status
Kept
Kept

119. start
in a thread

120. in

121. my $p = Promise.in(3);

122. my $p = Promise.in(3);
!
for 1..5 {
say "$_ {$p.status}";
sleep 1;
}

123. my $p = Promise.in(3);
!
for 1..5 {
say "$_ {$p.status}";
sleep 1;
}

124. 1 Planned

125. 1 Planned
2 Planned

126. 1 Planned
2 Planned
3 Planned

127. 1 Planned
2 Planned
3 Planned
4 Kept

128. 1 Planned
2 Planned
3 Planned
4 Kept
5 Kept

129. Example:
Sleep Sort

130. !
for @*ARGS -> $a {
!
!
!
!
}

131. !
for @*ARGS -> $a {
!
!
!
!
}

132. !
for @*ARGS -> $a {
@promises.push(
Promise.in($a).then({
say $a;
})
);
}
!
await(|@promises);

133. my @promises;
for @*ARGS -> $a {
@promises.push(
Promise.in($a).then({
say $a;
})
);
}
!
await(|@promises);

134. my @promises;
for @*ARGS -> $a {
@promises.push(
Promise.in($a).then({
say $a;
})
);
}
!
await(|@promises);

135. my @promises;
for @*ARGS -> $a {
@promises.push(
Promise.in($a).then({
say $a;
})
);
}
!
await(|@promises);

136. my @promises;
for @*ARGS -> $a {
@promises.push(
Promise.in($a).then({
say $a;
})
);
}
!
await(|@promises);

137. $ ./sleep-sort.pl

138. $ ./sleep-sort.pl 3 1 2

139. $ ./sleep-sort.pl 3 1 2
1

140. $ ./sleep-sort.pl 3 1 2
1
2

141. $ ./sleep-sort.pl 3 1 2
1
2
3

142. Home work:
Channels inside
Promises

143. More:
Schedulers

144. More:
Suppliers

145. More:
I/O and Suppliers

146. More:
Signals

147. More:
Threads

148. More:
Atomic

149. More:
Locks

150. More:
Semaphores

151. __END__

152. Andrew Shitov
andy@shitov.ru April 2015