org.apache.tinkerpop.gremlin.process.computer.VertexProgram.getMemoryComputeKeys java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 LocalDateTime l =new LocalDateTime()
LocalDateTime.now()
DateTimeFormatter formatter;String text;formatter.parseLocalDateTime(text)
Smart code suggestions by Tabnine
}

public FulgoraMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final String key : vertexProgram.getMemoryComputeKeys()) {
      MemoryHelper.validateKey(key);
      this.memoryKeys.add(key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.add(mapReduce.getMemoryKey());
  }
}

public FulgoraMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final MemoryComputeKey key : vertexProgram.getMemoryComputeKeys()) {
      this.memoryKeys.put(key.getKey(), key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
}

public void addVertexProgramMemoryComputeKeys(final VertexProgram<?> vertexProgram) {
  vertexProgram.getMemoryComputeKeys().forEach(key -> this.memoryComputeKeys.put(key.getKey(), key));
}

public static void validateProgramOnComputer(final GraphComputer computer, final VertexProgram vertexProgram) {
  if (vertexProgram.getMemoryComputeKeys().contains(null))
    throw Memory.Exceptions.memoryKeyCanNotBeNull();
  if (vertexProgram.getMemoryComputeKeys().contains(""))
    throw Memory.Exceptions.memoryKeyCanNotBeEmpty();
  final GraphComputer.Features graphComputerFeatures = computer.features();
  final VertexProgram.Features vertexProgramFeatures = vertexProgram.getFeatures();
  for (final Method method : VertexProgram.Features.class.getMethods()) {
    if (method.getName().startsWith("requires")) {
      final boolean supports;
      final boolean requires;
      try {
        supports = (boolean) GraphComputer.Features.class.getMethod(method.getName().replace("requires", "supports")).invoke(graphComputerFeatures);
        requires = (boolean) method.invoke(vertexProgramFeatures);
      } catch (final Exception e) {
        throw new IllegalStateException("A reflection exception has occurred: " + e.getMessage(), e);
      }
      if (requires && !supports)
        throw new IllegalStateException("The vertex program can not be executed on the graph computer: " + method.getName());
    }
  }
}

public TinkerMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final MemoryComputeKey memoryComputeKey : vertexProgram.getMemoryComputeKeys()) {
      this.memoryKeys.put(memoryComputeKey.getKey(), memoryComputeKey);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
}

public SparkMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers, final JavaSparkContext sparkContext) {
  if (null != vertexProgram) {
    for (final MemoryComputeKey key : vertexProgram.getMemoryComputeKeys()) {
      this.memoryComputeKeys.put(key.getKey(), key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryComputeKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
  for (final MemoryComputeKey memoryComputeKey : this.memoryComputeKeys.values()) {
    this.sparkMemory.put(
        memoryComputeKey.getKey(),
        sparkContext.accumulator(ObjectWritable.empty(), memoryComputeKey.getKey(), new MemoryAccumulator<>(memoryComputeKey)));
  }
  this.broadcast = sparkContext.broadcast(Collections.emptyMap());
}

public void addVertexProgramMemoryComputeKeys(final VertexProgram<?> vertexProgram) {
  vertexProgram.getMemoryComputeKeys().forEach(key -> this.memoryComputeKeys.put(key.getKey(), key));
}

public FulgoraMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final String key : vertexProgram.getMemoryComputeKeys()) {
      MemoryHelper.validateKey(key);
      this.memoryKeys.add(key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.add(mapReduce.getMemoryKey());
  }
}

public DuctileMemory(VertexProgram<M> vertexProgram, Set<MapReduce<?, ?, ?, ?, R>> mapReducers) {
if (null != vertexProgram) {
  for (String key : vertexProgram.getMemoryComputeKeys()) {
  MemoryHelper.validateKey(key);
  memoryKeys.add(key);
  }
}
for (MapReduce<?, ?, ?, ?, R> mapReduce : mapReducers) {
  memoryKeys.add(mapReduce.getMemoryKey());
}
}

public static void validateProgramOnComputer(final GraphComputer computer, final VertexProgram vertexProgram) {
  if (vertexProgram.getMemoryComputeKeys().contains(null))
    throw Memory.Exceptions.memoryKeyCanNotBeNull();
  if (vertexProgram.getMemoryComputeKeys().contains(""))
    throw Memory.Exceptions.memoryKeyCanNotBeEmpty();
  final GraphComputer.Features graphComputerFeatures = computer.features();
  final VertexProgram.Features vertexProgramFeatures = vertexProgram.getFeatures();
  for (final Method method : VertexProgram.Features.class.getMethods()) {
    if (method.getName().startsWith("requires")) {
      final boolean supports;
      final boolean requires;
      try {
        supports = (boolean) GraphComputer.Features.class.getMethod(method.getName().replace("requires", "supports")).invoke(graphComputerFeatures);
        requires = (boolean) method.invoke(vertexProgramFeatures);
      } catch (final Exception e) {
        throw new IllegalStateException("A reflection exception has occurred: " + e.getMessage(), e);
      }
      if (requires && !supports)
        throw new IllegalStateException("The vertex program can not be executed on the graph computer: " + method.getName());
    }
  }
}

public TinkerMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final MemoryComputeKey memoryComputeKey : vertexProgram.getMemoryComputeKeys()) {
      this.memoryKeys.put(memoryComputeKey.getKey(), memoryComputeKey);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
}

public TinkerMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers) {
  this.currentMap = new ConcurrentHashMap<>();
  this.previousMap = new ConcurrentHashMap<>();
  if (null != vertexProgram) {
    for (final MemoryComputeKey memoryComputeKey : vertexProgram.getMemoryComputeKeys()) {
      this.memoryKeys.put(memoryComputeKey.getKey(), memoryComputeKey);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
}

public SparkMemory(final VertexProgram<?> vertexProgram, final Set<MapReduce> mapReducers, final JavaSparkContext sparkContext) {
  if (null != vertexProgram) {
    for (final MemoryComputeKey key : vertexProgram.getMemoryComputeKeys()) {
      this.memoryComputeKeys.put(key.getKey(), key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryComputeKeys.put(mapReduce.getMemoryKey(), MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
  for (final MemoryComputeKey memoryComputeKey : this.memoryComputeKeys.values()) {
    this.sparkMemory.put(
        memoryComputeKey.getKey(),
        sparkContext.accumulator(ObjectWritable.empty(), memoryComputeKey.getKey(), new MemoryAccumulator<>(memoryComputeKey)));
  }
  this.broadcast = sparkContext.broadcast(Collections.emptyMap());
}

public GraknSparkMemory(final VertexProgram<?> vertexProgram,
            final Set<MapReduce> mapReducers,
            final JavaSparkContext sparkContext) {
  if (null != vertexProgram) {
    for (final MemoryComputeKey key : vertexProgram.getMemoryComputeKeys()) {
      this.memoryComputeKeys.put(key.getKey(), key);
    }
  }
  for (final MapReduce mapReduce : mapReducers) {
    this.memoryComputeKeys.put(
        mapReduce.getMemoryKey(),
        MemoryComputeKey.of(mapReduce.getMemoryKey(), Operator.assign, false, false));
  }
  for (final MemoryComputeKey memoryComputeKey : this.memoryComputeKeys.values()) {
    this.sparkMemory.put(
        memoryComputeKey.getKey(),
        sparkContext.accumulator(ObjectWritable.empty(), memoryComputeKey.getKey(),
            new MemoryAccumulator<>(memoryComputeKey)));
  }
  this.broadcast = sparkContext.broadcast(Collections.emptyMap());
}

Javadoc

The Memory keys that will be used during the computation. These are the only keys that can be read or written throughout the life of the GraphComputer. The default is an empty set.

Popular methods of VertexProgram

workerIterationEnd
This method is called at the end of each iteration of each "computational chunk." The set of vertice
workerIterationStart
This method is called at the start of each iteration of each "computational chunk." The set of verti
createVertexProgram
A helper method to construct a VertexProgram given the content of the supplied configuration. The cl
execute
This method denotes the main body of the computation and is executed on each vertex in the graph. Th
getMessageCombiner
Combine the messages in route to a particular vertex. Useful to reduce the amount of data transmitte
getVertexComputeKeys
The org.apache.tinkerpop.gremlin.structure.Element properties that will be mutated during the comput
setup
The method is called at the beginning of the computation. The method is global to the GraphComputer
terminate
The method is called at the end of each iteration to determine if the computation is complete. The m
getMapReducers
The set of MapReduce jobs that are associated with the VertexProgram. This is not necessarily the ex
storeState
When it is necessary to store the state of the VertexProgram, this method is called. This is typical
clone
When multiple workers on a single machine need VertexProgram instances, it is possible to use clone.
getElementComputeKeys

Popular in Java

Reactive rest calls using spring rest template
requestLocationUpdates (LocationManager)
getSystemService (Context)
getResourceAsStream (ClassLoader)
InputStreamReader (java.io)
A class for turning a byte stream into a character stream. Data read from the source input stream is
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to
SSLHandshakeException (javax.net.ssl)
The exception that is thrown when a handshake could not be completed successfully.
Options (org.apache.commons.cli)
Main entry-point into the library. Options represents a collection of Option objects, which describ

How to use getMemoryComputeKeysmethodin org.apache.tinkerpop.gremlin.process.computer.VertexProgram

Best Java code snippets using org.apache.tinkerpop.gremlin.process.computer.VertexProgram.getMemoryComputeKeys (Showing top 14 results out of 315)

How to use
getMemoryComputeKeys
method
in
org.apache.tinkerpop.gremlin.process.computer.VertexProgram