[DynInst_API:] [dyninst/dyninst] 87cf6b: Continue to fix non-deterministic behaviors of par...

[Xiaozhu Meng <xmeng@xxxxxxxxxxx>]

  Branch: refs/heads/new-parallel-parsing
  Home:   https://github.com/dyninst/dyninst
  Commit: 87cf6b8dcc0940ced7032b9c52cf4cb127615970
      https://github.com/dyninst/dyninst/commit/87cf6b8dcc0940ced7032b9c52cf4cb127615970
  Author: Xiaozhu Meng <xmeng@xxxxxxxxxxx>
  Date:   2018-09-23 (Sun, 23 Sep 2018)

  Changed paths:
    M parseAPI/src/CodeObject.C
    M parseAPI/src/ParseData.C
    M parseAPI/src/ParseData.h
    M parseAPI/src/Parser.C
    M parseAPI/src/Parser.h
    M parseAPI/src/ParserDetails.C
    M parseAPI/src/ParserDetails.h

  Log Message:
  -----------
  Continue to fix non-deterministic behaviors of parallel parsing

1. Force two rules to simplify the interactions between threads
1.A. Each basic block should be parsed and created only by one thread.
1.B. Each edge should be parsed and created only by one thread. To do
     this, we add edges source address into the ParseWorkElem. We also
     need to adjust non-returning function analysis because only one
     of shared functions will continue parsing and have the return
     status. All other functions should be delayed and wait for the
     winning function to finish parsing

These two rules ensure that we do not need a large critical section
 when we look for the correct source block of an edge during parsing
(See 2 for more detail)

2. When parsing an edge, the source block of the edge could have
   been split by the same thread. We need to follow the fallthrough
   edge to find the correct Block object that contains the edge.

   The two rules above ensure that the source block would not be
   split by a different thread, thus we do not need to build a
   large critical for when following the fall-through edges.

3. At finalizing time, fix the block spliting implementiation
   caused by functions sharing code. During parallel parsing,
   there is no range lookup because building a range lookup
   would cause mutual exclusion for threads. So, during parallel
   parsing, we only split blocks within a thread. For functions
   sharing code, this means overlapping blocks in separate functions.



      **NOTE:** This service has been marked for deprecation: https://developer.github.com/changes/2018-04-25-github-services-deprecation/

      Functionality will be removed from GitHub.com on January 31st, 2019.