@mfjs/compiler/par.js

// Generated by CoffeeScript 1.10.0
(function() {
  var ParBlockNode, ParBranchedNode, Scope, SeqBindNode, assert, blockSortAlgs, builder, config, graph, kit, mkGroup, usedOnLeftOrder, usedOrder,
    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  kit = require("./kit");

  Scope = require("./scope").Scope;

  builder = require("./builder");

  assert = require("assert");

  config = require("./config");

  graph = require("./graph");

  ParBlockNode = (function(superClass) {
    extend(ParBlockNode, superClass);

    function ParBlockNode(sort) {
      this.sort = sort;
      this.reorder = this.sort.reorder;
      ParBlockNode.__super__.constructor.call(this);
    }

    ParBlockNode.prototype._getBuilder = function() {
      var b, block, cur, eff, i, j, k, l, last, len, len1, len2, m, pure, reorder;
      if (!this.block.length) {
        return builder.empty();
      }
      block = this.sort(this.block);
      cur = builder.empty();
      reorder = this.reorder;
      for (k = 0, len = block.length; k < len; k++) {
        i = block[k];
        if (i.length === 1) {
          cur = cur.append(i[0].getBuilder());
          continue;
        }
        pure = [];
        eff = [];
        if (reorder) {
          for (l = 0, len1 = i.length; l < len1; l++) {
            j = i[l];
            b = j.getBuilder();
            if (j.eff) {
              eff.push(b.toExpr());
            } else {
              pure.push.apply(pure, b.toBlock());
            }
          }
          cur = cur.append(builder.purePrefix(builder.pure(pure), builder.exprEff(kit.seq.apply(kit, eff))));
        } else {
          last = builder.empty();
          for (m = 0, len2 = i.length; m < len2; m++) {
            j = i[m];
            b = j.getBuilder();
            if (j.eff) {
              eff.push((last = b).toExpr());
            } else {
              last.append(b);
            }
          }
          cur = cur.append(builder.exprEff(kit.seq.apply(kit, eff)));
        }
      }
      return cur;
    };

    return ParBlockNode;

  })(graph.BlockNode);

  graph.regNodeType("parBlockNode", ParBlockNode);

  Scope.prototype.seqBlockNode = Scope.prototype.blockNode;

  Scope.prototype.blockNode = function() {
    var alg, b, p;
    b = this.policy.opts.block;
    if (b != null) {
      p = b.par;
    }
    if (p === true) {
      p = "byUsage";
    }
    alg = blockSortAlgs[p];
    if (alg == null) {
      return this.seqBlockNode();
    }
    return this.parBlockNode(alg);
  };

  mkGroup = function(reorder, order) {
    return function(b) {
      var c, d, deps, i, ix, j, jx, k, l, len, len1, len2, len3, level, lx, m, n, o, q, ref, ref1, removed, res, x;
      deps = [];
      for (x = k = 0, len = b.length; k < len; x = ++k) {
        i = b[x];
        deps.push([i, n = []]);
        ref = b.slice(0, x);
        for (l = 0, len1 = ref.length; l < len1; l++) {
          j = ref[l];
          if (order(j, i)) {
            n.push(j);
          }
        }
      }
      removed = {};
      res = [];
      while (true) {
        lx = [];
        level = [];
        for (ix = m = 0, len2 = deps.length; m < len2; ix = ++m) {
          ref1 = deps[ix], c = ref1[0], d = ref1[1];
          jx = 0;
          while (true) {
            if (jx === d.length) {
              break;
            }
            j = d[jx];
            if (removed[j.id]) {
              d.splice(jx, 1);
            } else {
              ++jx;
            }
          }
          if (d.length) {
            if (!reorder) {
              break;
            }
          } else {
            lx.push(ix);
            level.push(c);
          }
        }
        assert.ok(level.length);
        for (o = lx.length - 1; o >= 0; o += -1) {
          ix = lx[o];
          deps.splice(ix, 1);
        }
        for (q = 0, len3 = level.length; q < len3; q++) {
          c = level[q];
          removed[c.id] = true;
        }
        res.push(level);
        if (!deps.length) {
          break;
        }
      }
      return res;
    };
  };

  usedOnLeftOrder = function(a, b) {
    var i, uses;
    uses = a.vdeps.uses;
    for (i in b.vdeps.mods) {
      if (uses[i]) {
        return true;
      }
    }
    return false;
  };

  usedOrder = function(a, b) {
    var i, mods, ref, uses;
    ref = a.vdeps, uses = ref.uses, mods = ref.mods;
    for (i in b.vdeps.mods) {
      if (uses[i] || mods[i]) {
        return true;
      }
    }
    return false;
  };

  blockSortAlgs = {
    all: function(b) {
      return [b];
    },
    reorderByUsage: mkGroup(true, usedOrder),
    reorderByLhsUsage: mkGroup(true, usedOnLeftOrder),
    byUsage: mkGroup(false, usedOrder),
    byLhsUsage: mkGroup(false, usedOnLeftOrder)
  };

  blockSortAlgs.reorderByUsage.reorder = true;

  blockSortAlgs.reorderByLhsUsage.reorder = true;

  blockSortAlgs.reorderByLhsUsage.all = true;

  SeqBindNode = (function(superClass) {
    extend(SeqBindNode, superClass);

    function SeqBindNode(body, deps) {
      SeqBindNode.__super__.constructor.call(this, body, deps);
    }

    SeqBindNode.prototype.assemblePar = function(deps, cur) {
      var i, k, x;
      for (x = k = deps.length - 1; k >= 0; x = k += -1) {
        i = deps[x];
        cur = i.append(cur);
      }
      return cur;
    };

    return SeqBindNode;

  })(graph.BindNode);

  graph.regNodeType("seqBindNode", SeqBindNode);

  Scope.prototype.defaultBindNode = Scope.prototype.bindNode;

  Scope.prototype.bindNode = function(body, deps) {
    switch (this.policy.opts.expr) {
      case "seq":
        return this.seqBindNode(body, deps);
      default:
        return this.defaultBindNode(body, deps);
    }
  };

  ParBranchedNode = (function(superClass) {
    extend(ParBranchedNode, superClass);

    function ParBranchedNode(fun, template) {
      ParBranchedNode.__super__.constructor.call(this, fun, template);
    }

    ParBranchedNode.prototype._getBuilder = function() {
      return ParBranchedNode.__super__._getBuilder.call(this);
    };

    return ParBranchedNode;

  })(graph.BranchedNode);

  Scope.prototype.seqBranchedNode = Scope.prototype.branchedNode;

  graph.regNodeType("parBranchedNode", ParBranchedNode);

  Scope.prototype.branchedNode = function(body, deps) {
    switch (this.policy.opts.branch) {
      case "par":
        return this.parBranchedNode(body, deps);
      default:
        return this.seqBranchedNode(body, deps);
    }
  };

}).call(this);