cleaning

Author: tomjoro

README.md

@@ -1,2 +1,48 @@
 # elixir_map_pmap_apmap_example
-Example of how to put asynchronous behavior behind an API in Elixir, using Parallel Map. Using map, pmap and an asynchronous pmap. 
+Example of how to put asynchronous behavior behind an API in Elixir, using Parallel Map. Using map, pmap and an asynchronous pmap.
+
+
+The cool thing about this code is, as a user of the function (the caller) you don't know
+which version it will use. In most other languages (like Javascript), this is an
+exceptionally bad idea, but in Elixir this is actually a common way to solve problems.
+
+"Javascript with Promises", by Daniel Parker has this warning:
+```
+WARNING
+Functions that invoke a callback synchronously in some cases and asynchronously in
+others create forks in the execution path that make your code less predictable.
+```
+
+But we ignore this warning in Elixir :) , because there is only one execution path
+for a delayed job - messages which your process will handle when it wants to.
+
+For example, the Logger works like this in Elixir. If the backlog of things to log is
+small, then it completes synchronously, otherwise it will decide to switch to
+asynchronous mode, just like magic.
+
+
+Here's what the code invoked looks like:
+```
+result = Parallel.map_or_pmap_or_apmap((0..10), fn(x) -> x * x end)
+```
+
+result will either be:
+
+```
+{:ok, result_arr} # result is available synchronously
+{:delayed, pid}  # this is going to take a while, I'll send you a message when it is ready
+```
+
+
+Depending on the size of the Range passed to the map_or_pmap_or_apmap function, the
+work can be accomplished in one of three ways:
+1. For small arrays <= 100 elements in size, it just runs in process synchronously
+1. For medium arrays <= 1000 elements in size, it runs parallel map (multiprocess), but synchronously
+1. For anything bigger it runs parallel map, but does it asynchronously and send a response when it
+it done with the work.
+
+```
+Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..10), fn(x) -> x * x end))
+Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..150), fn(x) -> x * x end))
+Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..1000000), fn(x) -> x * x end))
+```

parallel.ex

@@ -6,36 +6,19 @@ defmodule Parallel do
 
   """
 
-  @doc """
-  runs a parallel map by spawning a bunch of processes and returns array of results
-  ## Parameters
-    - collection: a collection that can be enumerated
-    - function: an anonymous function to apply to each element in collection
-
-  ## Examples
-    iex> Parallel.pmap((0..4), fn(x) -> x * x end)
-    [0, 1, 4, 9, 16]
-  """
-  def pmap(collection, function) do
-    me = self
-    pid_list = Enum.map(collection, fn (elem) ->
-      spawn_link fn -> (send me, { self, function.(elem) }) end
-    end)
-    Enum.map(pid_list, fn (pid) ->
-      receive do { ^pid, result } -> result end
-    end)
-  end
-
-  def pmap_wrapper(me, collection, function) do
-    result = pmap(collection, function)
-    send me, {self, result}
-  end
 
   @doc """
-    runs a parallel map by either a) in current process, b) synchronous multi-process or
+    This shows a common technique in Elixir/Erlang. If something is fast, do
+    it synchronous (either in process or multi-process), and it looks like
+    a big problem, then do it asynchronous, which lets the caller do other
+    work and check back later for the result.
+
+    Runs a parallel map by either a) in current process, b) synchronous multi-process or
     c) fully asynchronous multi-process, and you need to wait for result.
 
-    It chooses which one to run based on the size of the collection
+    It chooses which one to run based on the size of the collection.
+
+    Only works with ranges currently.
 
   ## Parameters
     - range: a collection that can be enumerated
@@ -50,7 +33,7 @@ defmodule Parallel do
     first..last = range
     result = case last - first do
         x when x > 1000 ->
-                          IO.puts("<delayed_map>")
+                          IO.puts("<delayed_pmap>")
                           pid = spawn_link( fn -> pmap_wrapper(me, range, function) end)
                           {:delayed, pid}
         x when x > 100 ->
@@ -72,17 +55,43 @@ defmodule Parallel do
     result
   end
 
+  @doc """
+  runs a parallel map by spawning a bunch of processes and returns array of results
+  ## Parameters
+    - collection: a collection that can be enumerated
+    - function: an anonymous function to apply to each element in collection
+
+  ## Examples
+    iex> Parallel.pmap((0..4), fn(x) -> x * x end)
+    [0, 1, 4, 9, 16]
+  """
+  def pmap(collection, function) do
+    me = self
+    pid_list = Enum.map(collection, fn (elem) ->
+      spawn_link fn -> (send me, { self, function.(elem) }) end
+    end)
+    Enum.map(pid_list, fn (pid) ->
+      receive do { ^pid, result } -> result end
+    end)
+  end
+
+  def pmap_wrapper(me, collection, function) do
+    result = pmap(collection, function)
+    send me, {self, result}
+  end
+
   def map(collection, function) do
     Enum.map(collection, function)
   end
 
-  def show_result(result) do
-    case result do
-      {:ok, arr} -> IO.puts(">> Running synchronously, I am waiting for results")
-                    IO.inspect(arr)
-      {:delayed, _} -> IO.puts(">> Running asynchronously, I am not going to wait for results")
-    end
-    result
+  def handle_result(result = {:delayed, pid}) do
+    IO.puts(">> Running asynchronously, I am not going to wait for results:")
+    waiting(pid)
+  end
+
+  def handle_result(result = {:ok, arr}) do
+    IO.puts(">> Ran synchronously, here are the results:")
+    IO.inspect(arr)
   end
 
   def run_fail_test do
@@ -102,25 +111,18 @@ defmodule Parallel do
     IO.puts "checking the 3 versions"
 
     # But what if you  only want to wait if it is a BIG one...
-    Parallel.show_result(Parallel.map_or_pmap_or_apmap((0..10), fn(x) -> x * x end))
-    Parallel.show_result(Parallel.map_or_pmap_or_apmap((0..150), fn(x) -> x * x end))
-    result = Parallel.show_result(Parallel.map_or_pmap_or_apmap((0..1000000), fn(x) -> x * x end))
-
-    case result do
-      {:delayed, pid} ->
-        start_waiting(pid)
-      {:ok, arr } -> IO.puts("not delayed")
-                   IO.inspect(arr)
-    end
+    Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..10), fn(x) -> x * x end))
+    Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..150), fn(x) -> x * x end))
+    Parallel.handle_result(Parallel.map_or_pmap_or_apmap((0..1000000), fn(x) -> x * x end))
   end
 
-  def start_waiting(pid) do
+  def waiting(pid) do
     receive do
-      { ^pid, result } -> IO.puts("done")
+      { ^pid, result } -> IO.puts("Results have ready. Yay!:")
                           IO.inspect(result)
     after
-      1_000 -> IO.puts "still waiting..."
-      start_waiting(pid)
+      1_000 -> IO.puts "still waiting... more hamsters needed..."
+      waiting(pid)
     end
   end