/** * Create new incoming message value factory * @param <M> message type * @return incoming message value factory */ public <M extends Writable> MessageValueFactory<M> createIncomingMessageValueFactory() { return classes.getIncomingMessageClasses().createMessageValueFactory(this); }
/** * Set incoming message class * @param incomingMessageClass incoming message class */ @Deprecated public void setIncomingMessageClass( Class<? extends Writable> incomingMessageClass) { if (!incomingMessageClasses.getMessageClass(). equals(incomingMessageClass)) { throw new IllegalArgumentException( "Cannot change incoming message class from " + incomingMessageClasses.getMessageClass() + " previously, to " + incomingMessageClass); } }
@Override public MessageStore<I, M> newStore( MessageClasses<I, M> messageClasses) { return new OneMessagePerVertexStore<I, M>( messageClasses.createMessageValueFactory(config), service, messageClasses.createMessageCombiner(config), config); }
@Override public MessageStore<I, M> newStore( MessageClasses<I, M> messageClasses) { Class<M> messageClass = messageClasses.getMessageClass(); MessageValueFactory<M> messageValueFactory = messageClasses.createMessageValueFactory(conf); MessageCombiner<? super I, M> messageCombiner = messageClasses.createMessageCombiner(conf); MessageStore messageStore; if (messageCombiner != null) { messageStore = newStoreWithoutCombiner( messageClass, messageValueFactory, messageClasses.getMessageEncodeAndStoreType());
ReflectionUtils.verifyTypes(incomingMessageClasses.getMessageClass(), computationTypes[3], "Incoming message type", computationClass); ReflectionUtils.verifyTypes(outgoingMessageClasses.getMessageClass(), computationTypes[4], "Outgoing message type", computationClass); outgoingMessageClasses.verifyConsistent(conf);
public MessageClasses getOutgoingMessageClasses( ImmutableClassesGiraphConfiguration conf) { MessageClasses messageClasses; if (sender == null || sender.getPiece() == null) { messageClasses = new DefaultMessageClasses( NoMessage.class, DefaultMessageValueFactory.class, null, MessageEncodeAndStoreType.BYTEARRAY_PER_PARTITION); } else { messageClasses = sender.getPiece().getMessageClasses(conf); } messageClasses.verifyConsistent(conf); return messageClasses; }
/** * Check if user set a combiner * * @return True iff user set a combiner class */ public boolean useOutgoingMessageCombiner() { return classes.getOutgoingMessageClasses().useMessageCombiner(); }
/** * Get message combiner class * @return message combiner class */ public Class<? extends MessageCombiner> getMessageCombinerClass() { MessageCombiner combiner = outgoingMessageClasses.createMessageCombiner(conf); return combiner != null ? combiner.getClass() : null; }
public boolean ignoreExistingVertices() { return previousMessageClasses != null && previousMessageClasses.ignoreExistingVertices(); }
/** * Get outgoing message encode and store type * @return outgoing message encode and store type */ public MessageEncodeAndStoreType getOutgoingMessageEncodeAndStoreType() { return classes.getOutgoingMessageClasses().getMessageEncodeAndStoreType(); }
/** * Create superstep classes by initiazling from current state * in configuration * @param conf Configuration * @return Superstep classes */ public static SuperstepClasses createAndExtractTypes( ImmutableClassesGiraphConfiguration conf) { return new SuperstepClasses( conf, conf.getComputationClass(), conf.getOutgoingMessageClasses(), conf.getOutgoingMessageClasses().createCopyForNewSuperstep()); }
nextCurrentMessageStore = new DiskBackedMessageStore<>( conf, oocEngine, messageStore, conf.getIncomingMessageClasses().useMessageCombiner(), serviceWorker.getSuperstep()); nextIncomingMessageStore = new DiskBackedMessageStore<>( conf, oocEngine, messageStore, conf.getOutgoingMessageClasses().useMessageCombiner(), serviceWorker.getSuperstep() + 1);
/** * Create a user combiner class * * @param <M> Message data * @return Instantiated user combiner class */ public <M extends Writable> MessageCombiner<? super I, M> createOutgoingMessageCombiner() { return classes.getOutgoingMessageClasses().createMessageCombiner(this); }
/** * Get the user's subclassed incoming message value class. * * @param <M> Message data * @return User's vertex message value class */ public <M extends Writable> Class<M> getIncomingMessageValueClass() { return classes.getIncomingMessageClasses().getMessageClass(); }
/** * Create new outgoing message value factory * @param <M> message type * @return outgoing message value factory */ public <M extends Writable> MessageValueFactory<M> createOutgoingMessageValueFactory() { return classes.getOutgoingMessageClasses().createMessageValueFactory(this); }
/** * Get the user's subclassed outgoing message value class. * * @param <M> Message type * @return User's vertex message value class */ public <M extends Writable> Class<M> getOutgoingMessageValueClass() { return classes.getOutgoingMessageClasses().getMessageClass(); }
@Override public MessageStore<I, M> newStore( MessageClasses<I, M> messageClasses) { return new ByteArrayMessagesPerVertexStore<I, M>( messageClasses.createMessageValueFactory(config), service, config); }
@Override public MessageClasses<I, M> getMessageClasses( ImmutableClassesGiraphConfiguration conf) { MessageClasses<I, M> messageClasses = null; MessageClasses<I, M> firstMessageClasses = null; for (AbstractPiece<I, V, E, M, WV, WM, S> innerPiece : innerPieces) { MessageClasses<I, M> cur = innerPiece.getMessageClasses(conf); Preconditions.checkState(cur != null); if (!cur.getMessageClass().equals(NoMessage.class)) { if (messageClasses != null) { throw new RuntimeException( "Only one piece combined through delegate (" + toString() + ") can send messages"); } messageClasses = cur; } if (firstMessageClasses == null) { firstMessageClasses = cur; } } return messageClasses != null ? messageClasses : firstMessageClasses; }
private <M extends Writable> InternalMessageStore<I, M> createMessageStore( ImmutableClassesGiraphConfiguration<I, ?, ?> conf, MessageClasses<I, M> messageClasses, PartitionSplitInfo<I> partitionInfo, boolean runAllChecks ) { InternalMessageStore<I, M> messageStore = InternalWrappedMessageStore.create(conf, messageClasses, partitionInfo); if (runAllChecks) { return new InternalChecksMessageStore<I, M>( messageStore, conf, messageClasses.createMessageValueFactory(conf)); } else { return messageStore; } }
@Override public void apply(AbstractPiece piece) { if (!piece.getClass().equals(Piece.class)) { Class<?>[] classList = getTypeArguments( AbstractPiece.class, piece.getClass()); Preconditions.checkArgument(classList.length == 7); ReflectionUtils.verifyTypes( vertexIdClass, classList[0], "vertexId", piece.getClass()); ReflectionUtils.verifyTypes( vertexValueClass, classList[1], "vertexValue", piece.getClass()); ReflectionUtils.verifyTypes( edgeValueClass, classList[2], "edgeValue", piece.getClass()); MessageClasses classes = piece.getMessageClasses(conf); Class<?> messageType = classes.getMessageClass(); if (messageType == null) { messageType = NoMessage.class; } ReflectionUtils.verifyTypes( messageType, classList[3], "message", piece.getClass()); ReflectionUtils.verifyTypes( workerContextValueClass, classList[4], "workerContextValue", piece.getClass()); // No need to check worker context message class at all ReflectionUtils.verifyTypes( executionStageClass, classList[6], "executionStage", piece.getClass()); } } });