Exemplo n.º 1
0
  /**
   * Sets remote candidate to done.
   *
   * @param ver Version.
   * @param pending Pending versions.
   * @param committed Committed versions.
   * @param rolledback Rolledback versions.
   * @return Lock owner.
   */
  @Nullable
  public CacheLockCandidates doneRemote(
      GridCacheVersion ver,
      Collection<GridCacheVersion> pending,
      Collection<GridCacheVersion> committed,
      Collection<GridCacheVersion> rolledback) {
    assert ver != null;

    if (log.isDebugEnabled())
      log.debug("Setting remote candidate to done [mvcc=" + this + ", ver=" + ver + "]");

    // Check remote candidate.
    GridCacheMvccCandidate cand = candidate(rmts, ver);

    if (cand != null) {
      assert rmts != null;
      assert !rmts.isEmpty();
      assert !cand.local() : "Remote candidate is marked as local: " + cand;
      assert !cand.nearLocal() : "Remote candidate is marked as near local: " + cand;

      cand.setOwner();
      cand.setUsed();

      List<GridCacheMvccCandidate> mvAfter = null;

      for (ListIterator<GridCacheMvccCandidate> it = rmts.listIterator(); it.hasNext(); ) {
        GridCacheMvccCandidate c = it.next();

        assert !c.nearLocal() : "Remote candidate marked as near local: " + c;

        if (c == cand) {
          if (mvAfter != null) for (GridCacheMvccCandidate mv : mvAfter) it.add(mv);

          break;
        } else if (!committed.contains(c.version())
            && !rolledback.contains(c.version())
            && pending.contains(c.version())) {
          it.remove();

          if (mvAfter == null) mvAfter = new LinkedList<>();

          mvAfter.add(c);
        }
      }
    }

    return allOwners();
  }
Exemplo n.º 2
0
  /**
   * For all remote candidates standing behind the candidate being salvaged marks their transactions
   * as system invalidate and marks these candidates as owned and used.
   *
   * @param ver Version to salvage.
   */
  public void salvageRemote(GridCacheVersion ver) {
    assert ver != null;

    GridCacheMvccCandidate cand = candidate(rmts, ver);

    if (cand != null) {
      assert rmts != null;
      assert !rmts.isEmpty();

      for (Iterator<GridCacheMvccCandidate> iter = rmts.iterator(); iter.hasNext(); ) {
        GridCacheMvccCandidate rmt = iter.next();

        // For salvaged candidate doneRemote will be called explicitly.
        if (rmt == cand) break;

        // Only Near and DHT remote candidates should be released.
        assert !rmt.nearLocal();

        IgniteInternalTx tx = cctx.tm().tx(rmt.version());

        if (tx != null) {
          tx.systemInvalidate(true);

          rmt.setOwner();
          rmt.setUsed();
        } else iter.remove();
      }
    }
  }
Exemplo n.º 3
0
        /** {@inheritDoc} */
        @SuppressWarnings({"unchecked"})
        @Override
        public void onOwnerChanged(
            GridCacheEntryEx entry, GridCacheMvccCandidate prev, GridCacheMvccCandidate owner) {
          assert entry != null;
          assert owner != prev : "New and previous owner are identical instances: " + owner;
          assert owner == null || prev == null || !owner.version().equals(prev.version())
              : "New and previous owners have identical versions [owner="
                  + owner
                  + ", prev="
                  + prev
                  + ']';

          if (log.isDebugEnabled())
            log.debug(
                "Received owner changed callback ["
                    + entry.key()
                    + ", owner="
                    + owner
                    + ", prev="
                    + prev
                    + ']');

          if (owner != null && (owner.local() || owner.nearLocal())) {
            Collection<? extends GridCacheFuture> futCol = futs.get(owner.version());

            if (futCol != null) {
              for (GridCacheFuture fut : futCol) {
                if (fut instanceof GridCacheMvccFuture && !fut.isDone()) {
                  GridCacheMvccFuture<Boolean> mvccFut = (GridCacheMvccFuture<Boolean>) fut;

                  // Since this method is called outside of entry synchronization,
                  // we can safely invoke any method on the future.
                  // Also note that we don't remove future here if it is done.
                  // The removal is initiated from within future itself.
                  if (mvccFut.onOwnerChanged(entry, owner)) return;
                }
              }
            }
          }

          if (log.isDebugEnabled())
            log.debug(
                "Lock future not found for owner change callback (will try transaction futures) [owner="
                    + owner
                    + ", prev="
                    + prev
                    + ", entry="
                    + entry
                    + ']');

          // If no future was found, delegate to transaction manager.
          if (cctx.tm().onOwnerChanged(entry, owner)) {
            if (log.isDebugEnabled()) log.debug("Found transaction for changed owner: " + owner);
          } else if (log.isDebugEnabled())
            log.debug("Failed to find transaction for changed owner: " + owner);

          for (FinishLockFuture f : finishFuts) f.recheck(entry);
        }
Exemplo n.º 4
0
  /** Assigns local lock. */
  private void reassign() {
    GridCacheMvccCandidate firstRmt = null;

    if (rmts != null) {
      for (GridCacheMvccCandidate cand : rmts) {
        if (firstRmt == null) firstRmt = cand;

        // If there is a remote owner, then local cannot be an owner,
        // so no reassignment happens.
        if (cand.owner()) return;
      }
    }

    if (locs != null) {
      boolean first = true;

      ListIterator<GridCacheMvccCandidate> it = locs.listIterator();

      while (it.hasNext()) {
        GridCacheMvccCandidate cand = it.next();

        if (first) {
          if (cand.read()) {
            if (cand.ready() && !cand.owner()) cand.setOwner();

            while (it.hasNext()) {
              cand = it.next();

              if (!cand.read()) break;

              if (cand.ready() && !cand.owner()) cand.setOwner();
            }

            return;
          } else if (cand.serializable()) {
            if (cand.owner() || !cand.ready()) return;

            cand.setOwner();

            return;
          }

          first = false;
        }

        if (cand.owner()) return;

        if (cand.ready()) {
          GridCacheMvccCandidate prev = nonRollbackPrevious(cand);

          // If previous has not been acquired, this candidate cannot acquire lock either,
          // so we move on to the next one.
          if (prev != null && !prev.owner()) continue;

          boolean assigned = false;

          if (!cctx.isNear() && firstRmt != null && cand.version().isGreater(firstRmt.version())) {
            // Check previous candidates for 2 cases:
            // 1. If this candidate is waiting for a smaller remote version,
            //    then we must check if previous candidate is the owner and
            //    has the same remote candidate version. In that case, we can
            //    safely set this candidate to owner as well.
            // 2. If this candidate is waiting for a smaller remote version,
            //    then we must check if previous candidate is the owner and
            //    any of the local candidates with versions smaller than first
            //    remote version have the same key as the previous owner. In
            //    that case, we can safely set this candidate to owner as well.
            while (prev != null && prev.owner()) {
              for (GridCacheMvccCandidate c : prev.parent().remoteMvccSnapshot()) {
                if (c.version().equals(firstRmt.version())) {
                  cand.setOwner();

                  assigned = true;

                  break; // For.
                }
              }

              if (!assigned) {
                for (GridCacheMvccCandidate c : locs) {
                  if (c == cand || c.version().isGreater(firstRmt.version())) break;

                  for (GridCacheMvccCandidate p = c.previous(); p != null; p = p.previous()) {
                    if (p.key().equals(prev.key())) {
                      cand.setOwner();

                      assigned = true;

                      break; // For.
                    }
                  }

                  if (assigned) break; // For.
                }
              }

              if (assigned) break; // While.

              prev = prev.previous();
            }
          }

          if (!assigned) {
            if (!cctx.isNear() && firstRmt != null) {
              if (cand.version().isLess(firstRmt.version())) {
                assert !cand.nearLocal();

                cand.setOwner();

                assigned = true;
              }
            } else {
              cand.setOwner();

              assigned = true;
            }
          }

          if (assigned) {
            assert !cand.serializable() : cand;

            it.remove();

            // Owner must be first in the list.
            locs.addFirst(cand);
          }

          return;
        }
      }
    }
  }
Exemplo n.º 5
0
  /**
   * Marks near-local candidate as ready and makes locks reassignment. Following reorderings are
   * performed when candidate is marked ready:
   *
   * <ul>
   *   <li/>All candidates preceding ready one are moved right after it.
   *   <li/>Near local candidate is assigned a mapped dht version. All remote non-pending candidates
   *       with version less then mapped dht version are marked as owned.
   * </ul>
   *
   * @param ver Version to mark as ready.
   * @param mappedVer Mapped dht version.
   * @param committedVers Committed versions.
   * @param rolledBackVers Rolled back versions.
   * @param pending Pending dht versions that are not owned and which version is less then mapped.
   * @return Lock owner after reassignment.
   */
  @Nullable
  public CacheLockCandidates readyNearLocal(
      GridCacheVersion ver,
      GridCacheVersion mappedVer,
      Collection<GridCacheVersion> committedVers,
      Collection<GridCacheVersion> rolledBackVers,
      Collection<GridCacheVersion> pending) {
    GridCacheMvccCandidate cand = candidate(locs, ver);

    if (cand != null) {
      assert cand.nearLocal() : "Near local candidate is not marked as near local: " + cand;

      cand.setReady();

      boolean setMapped = cand.otherVersion(mappedVer);

      assert setMapped
          : "Failed to set mapped dht version for near local candidate [mappedVer="
              + mappedVer
              + ", cand="
              + cand
              + ']';

      // For near locals we move all not owned candidates after this one.
      List<GridCacheMvccCandidate> mvAfter = null;

      for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(); it.hasNext(); ) {
        GridCacheMvccCandidate c = it.next();

        assert c.nearLocal() : "Near local candidate is not marked as near local: " + c;

        if (c == cand) {
          if (mvAfter != null) for (GridCacheMvccCandidate mv : mvAfter) it.add(mv);

          break;
        } else {
          if (c.owner()) continue;

          assert !c.ready() || (c.read() && cand.read())
              : "Cannot have more then one ready near-local candidate [c="
                  + c
                  + ", cand="
                  + cand
                  + ", mvcc="
                  + this
                  + ']';

          it.remove();

          if (mvAfter == null) mvAfter = new LinkedList<>();

          mvAfter.add(c);
        }
      }

      // Mark all remote candidates with less version as owner unless it is pending.
      if (rmts != null) {
        for (GridCacheMvccCandidate rmt : rmts) {
          GridCacheVersion rmtVer = rmt.version();

          if (rmtVer.isLess(mappedVer)) {
            if (!pending.contains(rmtVer) && !mappedVer.equals(rmt.ownerVersion())) rmt.setOwner();
          } else {
            // Remote version is greater, so need to check if it was committed or rolled back.
            if (committedVers.contains(rmtVer) || rolledBackVers.contains(rmtVer)) rmt.setOwner();
          }
        }
      }

      reassign();
    }

    return allOwners();
  }
Exemplo n.º 6
0
  /**
   * @param cand Candidate to add.
   * @return {@code False} if failed to add candidate and transaction should be cancelled.
   */
  private boolean add0(GridCacheMvccCandidate cand) {
    assert cand != null;

    // Local.
    if (cand.local()) {
      if (locs == null) locs = new LinkedList<>();

      if (!cand.nearLocal()) {
        if (!locs.isEmpty()) {
          if (cand.serializable()) {
            Iterator<GridCacheMvccCandidate> it = locs.descendingIterator();

            if (cand.read()) {
              while (it.hasNext()) {
                GridCacheMvccCandidate c = it.next();

                if (!c.serializable()) return false;

                if (!c.read()) {
                  if (compareSerializableVersion(c, cand)) break;
                  else return false;
                }
              }
            } else {
              while (it.hasNext()) {
                GridCacheMvccCandidate c = it.next();

                if (!c.serializable() || !compareSerializableVersion(c, cand)) return false;

                if (!c.read()) break;
              }
            }

            locs.addLast(cand);

            return true;
          }

          GridCacheMvccCandidate first = locs.getFirst();

          if (first.owner()) {
            // If reentry, add at the beginning. Note that
            // no reentry happens for DHT-local candidates.
            if (!cand.dhtLocal() && first.threadId() == cand.threadId()) {
              assert !first.serializable();

              cand.setOwner();
              cand.setReady();
              cand.setReentry();

              locs.addFirst(cand);

              return true;
            }
          }

          // Iterate in reverse order.
          for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(locs.size());
              it.hasPrevious(); ) {
            GridCacheMvccCandidate c = it.previous();

            assert !c.version().equals(cand.version())
                : "Versions can't match [existing=" + c + ", new=" + cand + ']';

            // Add after the owner or serializable tx.
            if (c.owner() || c.serializable()) {
              // Threads are checked above.
              assert cand.dhtLocal() || c.threadId() != cand.threadId();

              // Reposition.
              it.next();

              it.add(cand);

              return true;
            }

            // If not the owner, add after the lesser version.
            if (c.version().isLess(cand.version())) {
              // Reposition.
              it.next();

              it.add(cand);

              return true;
            }
          }
        }

        // Either list is empty or candidate is first.
        locs.addFirst(cand);
      } else
        // For near local candidates just add it to the end of list.
        locs.add(cand);
    }
    // Remote.
    else {
      assert !cand.serializable() && !cand.read() : cand;

      if (rmts == null) rmts = new LinkedList<>();

      assert !cand.owner() || localOwners() == null
          : "Cannot have local and remote owners "
              + "at the same time [cand="
              + cand
              + ", locs="
              + locs
              + ", rmts="
              + rmts
              + ']';

      GridCacheMvccCandidate cur = candidate(rmts, cand.version());

      // For existing candidates, we only care about owners and keys.
      if (cur != null) {
        if (cand.owner()) cur.setOwner();

        return true;
      }

      // Either list is empty or candidate is last.
      rmts.add(cand);
    }

    return true;
  }