add more priority function (P = SI - SO)
add 2 variable to keep track of number of message read/writen
avoid using lock
Worker clean up task context but not immediately (because master may
acces to the task to retrieve its neighbor)
- worker marks the task as deleted and actual clean up when the next
  task to be marked as delete
new merge:
 - have a clean code separation from the old lpel
 - 2 lpel (decen & hrc) now have different task/worker/stream structure
   and methods. This make it easy for future developing of both
   approaches
 - decen & hrc share the interface with snet (lpel_main) and hardware
   functions (hwloc)
 - they also share streamset (organising a set of stream descriptors)
add free stream/sd list
 - each worker has a list of free streams and a list of freem stream
   descriptor
 - elements in these list can be completely free or half free depending
   on if it still have link to others
 - this help to avoid lock when keeping track of neighbours
master destroy zombie task
 - worker sends zombie task to master so that it can update the priority
   of the neighbors
 - master will destroy the zombie tasks
entry/exit stream, entry stream is bounded
 - entry task: written by source
 - exit task: read by sink
 - this is used to design different priority functions for entry/exit
   task
 - entry task is bounded to avoid out of memory (this is needed only
   when source/sink boxes are used)
cleanup master's mailbox before terminating
 - worker may send request or return zombie task to master when the
   program ends
 - master should process these messages before terminating
using read/write counter to keep track of the stream fill level
- this way will avoid using lock
add stream debug print
use list of free wrapper
 - avoid delete list of stream and stream descriptior of the wrapper
 - these stream/sd may be only half free and still linked by others
add comment & fix small bug:
 - bounded entry stream: fetch_sub (empty_semaphore)
trivial: bug fix
trivial: to have exclusive mapping, number of workers <= number of
processors
Bug: while terminating master & workers
 - master terminates when it gets terminating message and there is no
   ready task
 - after master terminate, it broadcasts terminating message to workers
trivial: only update the heap if task priority changes
update entry/exit stream
 - when task has only entry/exit stream, its countRec is -1 (guideline
   for the priority function)
add wakedup member to the task structure
 - this member indicates if a task is waked up before returning (as
   blocked)
 - when master gets a blocked task and it has been waked up before,
   master will treat it as ready task
 - in the previous implementation, master delays waking up. This cause
   imprecise scheduling behavior
modify priority of created task & clean up
 - created task does not set up input/output stream yet, set as highest
 - clean up task type (no longer needed)
cheduling cycle = rec_limit_factor * FAN_OUT
 - task's cheduling cyle should be proportional to its amount of output
   streams