anchor.diff:                              }
   
                           let partitions = sources |> Seq.toArray |> Partitions.ofArray workerCount
  +                        let! targetedworkerSupport = Cloud.IsTargetedWorkerSupported
                           let! results = 
  -                            partitions 
  -                            |> Array.mapi (fun i cfiles -> (createTask cfiles collectorf, workers.[i % workers.Length])) 
  -                            |> Cloud.Parallel
  +                            if targetedworkerSupport then
  +                                partitions 
  +                                |> Array.mapi (fun i cfiles -> (createTask cfiles collectorf, workers.[i % workers.Length])) 
  +                                |> Cloud.Parallel
  +                            else
  +                                partitions 
  +                                |> Array.map (fun cfiles -> createTask cfiles collectorf) 
  +                                |> Cloud.Parallel
                           return! combiner results
                   } }
   
  
positive.code:                         // TODO : need a scheduling algorithm to assign partition indices
                          //        to workers according to current cache state.
                          //        for now blindly assign partitions among workers.
  
                          let! results =
                              partitions
                              |> Partitions.ofArray workerCount
                              |> Seq.filter (not << Array.isEmpty)
                              |> Seq.mapi (fun i partitions -> (computePartitions partitions, workers.[i % workers.Length]))
                              |> Cloud.Parallel
  
                          return! combiner results
                  }
          }
  
negative.code:                         }
                      if not (fileSize = 0L) then 
                          let partitions = Partitions.ofLongRange workerCount fileSize
                          let! targetedworkerSupport = Cloud.IsTargetedWorkerSupported
                          let! results = 
                              if targetedworkerSupport then
                                  partitions 
                                  |> Array.mapi (fun i (s, e) -> (createTask s e collectorf, workers.[i % workers.Length])) 
                                  |> Cloud.Parallel
                              else
                                  partitions 
                                  |> Array.map (fun (s, e) -> createTask s e collectorf) 
                                  |> Cloud.Parallel
                          return! combiner results 
                      else
                          return! projection collector.Result
  