/src/test/run-pass/task-comm.rs

http://github.com/jruderman/rust · Rust · 150 lines · 118 code · 31 blank · 1 comment · 10 complexity · 7670b83da9a06f32a35f43014ba733e1 MD5 · raw file

  1. use std;
  2. import task;
  3. import task::task;
  4. import comm;
  5. import comm::chan;
  6. import comm::port;
  7. import comm::send;
  8. import comm::recv;
  9. fn main() {
  10. test00();
  11. // test01();
  12. test02();
  13. test04();
  14. test05();
  15. test06();
  16. }
  17. fn test00_start(ch: chan<int>, message: int, count: int) {
  18. debug!{"Starting test00_start"};
  19. let mut i: int = 0;
  20. while i < count {
  21. debug!{"Sending Message"};
  22. send(ch, message + 0);
  23. i = i + 1;
  24. }
  25. debug!{"Ending test00_start"};
  26. }
  27. fn test00() {
  28. let number_of_tasks: int = 1;
  29. let number_of_messages: int = 4;
  30. debug!{"Creating tasks"};
  31. let po = port();
  32. let ch = chan(po);
  33. let mut i: int = 0;
  34. let mut results = ~[];
  35. while i < number_of_tasks {
  36. i = i + 1;
  37. do task::task().future_result(|-r| {
  38. results += ~[r];
  39. }).spawn |copy i| {
  40. test00_start(ch, i, number_of_messages);
  41. }
  42. }
  43. let mut sum: int = 0;
  44. for results.each |r| {
  45. i = 0;
  46. while i < number_of_messages { sum += recv(po); i = i + 1; }
  47. }
  48. for results.each |r| { future::get(r); }
  49. debug!{"Completed: Final number is: "};
  50. assert (sum ==
  51. number_of_messages *
  52. (number_of_tasks * number_of_tasks + number_of_tasks) /
  53. 2);
  54. }
  55. fn test01() {
  56. let p = port();
  57. debug!{"Reading from a port that is never written to."};
  58. let value: int = recv(p);
  59. log(debug, value);
  60. }
  61. fn test02() {
  62. let p = port();
  63. let c = chan(p);
  64. debug!{"Writing to a local task channel."};
  65. send(c, 42);
  66. debug!{"Reading from a local task port."};
  67. let value: int = recv(p);
  68. log(debug, value);
  69. }
  70. fn test04_start() {
  71. debug!{"Started task"};
  72. let mut i: int = 1024 * 1024;
  73. while i > 0 { i = i - 1; }
  74. debug!{"Finished task"};
  75. }
  76. fn test04() {
  77. debug!{"Spawning lots of tasks."};
  78. let mut i: int = 4;
  79. while i > 0 { i = i - 1; task::spawn(|| test04_start() ); }
  80. debug!{"Finishing up."};
  81. }
  82. fn test05_start(ch: chan<int>) {
  83. send(ch, 10);
  84. send(ch, 20);
  85. send(ch, 30);
  86. send(ch, 30);
  87. send(ch, 30);
  88. }
  89. fn test05() {
  90. let po = comm::port();
  91. let ch = chan(po);
  92. task::spawn(|| test05_start(ch) );
  93. let mut value: int;
  94. value = recv(po);
  95. value = recv(po);
  96. value = recv(po);
  97. log(debug, value);
  98. }
  99. fn test06_start(&&task_number: int) {
  100. debug!{"Started task."};
  101. let mut i: int = 0;
  102. while i < 1000000 { i = i + 1; }
  103. debug!{"Finished task."};
  104. }
  105. fn test06() {
  106. let number_of_tasks: int = 4;
  107. debug!{"Creating tasks"};
  108. let mut i: int = 0;
  109. let mut results = ~[];
  110. while i < number_of_tasks {
  111. i = i + 1;
  112. do task::task().future_result(|-r| {
  113. results += ~[r];
  114. }).spawn |copy i| {
  115. test06_start(i);
  116. };
  117. }
  118. for results.each |r| { future::get(r); }
  119. }