Java Code Examples for org.apache.flink.types.LongValue#setValue()

/**
 * Executes the latency benchmark with the given number of records.
 *
 * @param records
 * 		records to pass through the network stack
 * @param flushAfterLastEmit
 * 		whether to flush the {@link RecordWriter} after the last record
 */
public void executeBenchmark(long records, boolean flushAfterLastEmit) throws Exception {
	final LongValue value = new LongValue();
	value.setValue(0);

	CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(records);

	for (int i = 1; i < records; i++) {
		recordWriter.emit(value);
	}
	value.setValue(records);
	recordWriter.broadcastEmit(value);
	if (flushAfterLastEmit) {
		recordWriter.flushAll();
	}

	recordsReceived.get(RECEIVER_TIMEOUT, TimeUnit.MILLISECONDS);
}
 

private void sendRecords(long records) throws IOException, InterruptedException {
	LongValue value = new LongValue(0);

	for (int i = 1; i < records; i++) {
		if (broadcastMode) {
			recordWriter.broadcastEmit(value);
		}
		else {
			recordWriter.emit(value);
		}
	}
	value.setValue(records);
	recordWriter.broadcastEmit(value);
	recordWriter.flushAll();

	finishSendingRecords();
}
 

private void sendRecords(long records) throws IOException, InterruptedException {
	LongValue value = new LongValue(0);

	for (int i = 1; i < records; i++) {
		if (broadcastMode) {
			recordWriter.broadcastEmit(value);
		}
		else {
			recordWriter.emit(value);
		}
	}
	value.setValue(records);
	recordWriter.broadcastEmit(value);
	recordWriter.flushAll();

	finishSendingRecords();
}
 

/**
 * Executes the latency benchmark with the given number of records.
 *
 * @param records
 * 		records to pass through the network stack
 * @param flushAfterLastEmit
 * 		whether to flush the {@link RecordWriter} after the last record
 */
public void executeBenchmark(long records, boolean flushAfterLastEmit) throws Exception {
	final LongValue value = new LongValue();
	value.setValue(0);

	CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(records);

	for (int i = 1; i < records; i++) {
		recordWriter.emit(value);
	}
	value.setValue(records);
	recordWriter.broadcastEmit(value);
	if (flushAfterLastEmit) {
		recordWriter.flushAll();
	}

	recordsReceived.get(RECEIVER_TIMEOUT, TimeUnit.MILLISECONDS);
}
 

private void sendRecords(long records) throws IOException, InterruptedException {
	LongValue value = new LongValue(0);

	for (int i = 1; i < records; i++) {
		if (broadcastMode) {
			recordWriter.broadcastEmit(value);
		}
		else {
			recordWriter.emit(value);
		}
	}
	value.setValue(records);
	recordWriter.broadcastEmit(value);
	recordWriter.flushAll();

	finishSendingRecords();
}
 

/**
 * Executes the throughput benchmark with the given number of records.
 *
 * @param records to pass through the network stack
 */
public void executeBenchmark(long records, long timeout) throws Exception {
	final LongValue value = new LongValue();
	value.setValue(0);

	long lastRecord = records / writerThreads.length;
	CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(lastRecord);

	for (LongRecordWriterThread writerThread : writerThreads) {
		writerThread.setRecordsToSend(lastRecord);
	}

	recordsReceived.get(timeout, TimeUnit.MILLISECONDS);
}
 

/**
 * Executes the throughput benchmark with the given number of records.
 *
 * @param records to pass through the network stack
 */
public void executeBenchmark(long records, long timeout) throws Exception {
	final LongValue value = new LongValue();
	value.setValue(0);

	long lastRecord = records / writerThreads.length;
	CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(lastRecord);

	for (LongRecordWriterThread writerThread : writerThreads) {
		writerThread.setRecordsToSend(lastRecord);
	}

	recordsReceived.get(timeout, TimeUnit.MILLISECONDS);
}
 

@Override
public void run() {
	LongValue current = new LongValue(0);

	try {
		while (true) {
			current.setValue(current.getValue() + 1);
			recordWriter.emit(current);
			recordWriter.flushAll();
		}
	} catch (Exception e) {
		ASYNC_PRODUCER_EXCEPTION = e;
	}
}
 

@Override
public void run() {
	LongValue current = new LongValue(0);

	try {
		while (true) {
			current.setValue(current.getValue() + 1);
			recordWriter.emit(current);
			recordWriter.flushAll();
		}
	} catch (Exception e) {
		ASYNC_PRODUCER_EXCEPTION = e;
	}
}
 

@Override
public Vertex<K, LongValue> reduce(Vertex<K, LongValue> left, Vertex<K, LongValue> right)
		throws Exception {
	LongValue count = left.f1;
	count.setValue(count.getValue() + right.f1.getValue());
	return left;
}
 

/**
 * Executes the throughput benchmark with the given number of records.
 *
 * @param records to pass through the network stack
 */
public void executeBenchmark(long records, long timeout) throws Exception {
	final LongValue value = new LongValue();
	value.setValue(0);

	long lastRecord = records / writerThreads.length;
	CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(lastRecord);

	for (LongRecordWriterThread writerThread : writerThreads) {
		writerThread.setRecordsToSend(lastRecord);
	}

	recordsReceived.get(timeout, TimeUnit.MILLISECONDS);
}
 

@Override
public void run() {
	LongValue current = new LongValue(0);

	try {
		while (true) {
			current.setValue(current.getValue() + 1);
			recordWriter.emit(current);
			recordWriter.flushAll();
		}
	} catch (Exception e) {
		ASYNC_PRODUCER_EXCEPTION = e;
	}
}
 

@Override
public Vertex<K, LongValue> reduce(Vertex<K, LongValue> left, Vertex<K, LongValue> right)
		throws Exception {
	LongValue count = left.f1;
	count.setValue(count.getValue() + right.f1.getValue());
	return left;
}
 

@Override
public LongValue reduce(LongValue value1, LongValue value2)
		throws Exception {
	value1.setValue(value1.getValue() + value2.getValue());
	return value1;
}
 

@Override
public int parseField(byte[] bytes, int startPos, int limit, byte[] delimiter, LongValue reusable) {

	if (startPos == limit) {
		setErrorState(ParseErrorState.EMPTY_COLUMN);
		return -1;
	}

	long val = 0;
	boolean neg = false;

	final int delimLimit = limit - delimiter.length + 1;

	this.result = reusable;
	
	if (bytes[startPos] == '-') {
		neg = true;
		startPos++;
		
		// check for empty field with only the sign
		if (startPos == limit || (startPos < delimLimit && delimiterNext(bytes, startPos, delimiter))) {
			setErrorState(ParseErrorState.NUMERIC_VALUE_ORPHAN_SIGN);
			return -1;
		}
	}
	
	for (int i = startPos; i < limit; i++) {
		if (i < delimLimit && delimiterNext(bytes, i, delimiter)) {
			if (i == startPos) {
				setErrorState(ParseErrorState.EMPTY_COLUMN);
				return -1;
			}
			reusable.setValue(neg ? -val : val);
			return i + delimiter.length;
		}
		if (bytes[i] < 48 || bytes[i] > 57) {
			setErrorState(ParseErrorState.NUMERIC_VALUE_ILLEGAL_CHARACTER);
			return -1;
		}
		val *= 10;
		val += bytes[i] - 48;

		// check for overflow / underflow
		if (val < 0) {
			// this is an overflow/underflow, unless we hit exactly the Long.MIN_VALUE
			if (neg && val == Long.MIN_VALUE) {
				reusable.setValue(Long.MIN_VALUE);
				
				if (i+1 >= limit) {
					return limit;
				} else if (i + 1 < delimLimit && delimiterNext(bytes, i + 1, delimiter)) {
					return i + 1 + delimiter.length;
				} else {
					setErrorState(ParseErrorState.NUMERIC_VALUE_OVERFLOW_UNDERFLOW);
					return -1;
				}
			}
			else {
				setErrorState(ParseErrorState.NUMERIC_VALUE_OVERFLOW_UNDERFLOW);
				return -1;
			}
		}
	}

	reusable.setValue(neg ? -val : val);
	return limit;
}
 

@Override
public LongValue copy(LongValue from, LongValue reuse) {
	reuse.setValue(from.getValue());
	return reuse;
}
 

@Override
public LongValue copy(LongValue from, LongValue reuse) {
	reuse.setValue(from.getValue());
	return reuse;
}
 

@Override
public int parseField(byte[] bytes, int startPos, int limit, byte[] delimiter, LongValue reusable) {

	if (startPos == limit) {
		setErrorState(ParseErrorState.EMPTY_COLUMN);
		return -1;
	}

	long val = 0;
	boolean neg = false;

	final int delimLimit = limit - delimiter.length + 1;

	this.result = reusable;
	
	if (bytes[startPos] == '-') {
		neg = true;
		startPos++;
		
		// check for empty field with only the sign
		if (startPos == limit || (startPos < delimLimit && delimiterNext(bytes, startPos, delimiter))) {
			setErrorState(ParseErrorState.NUMERIC_VALUE_ORPHAN_SIGN);
			return -1;
		}
	}
	
	for (int i = startPos; i < limit; i++) {
		if (i < delimLimit && delimiterNext(bytes, i, delimiter)) {
			if (i == startPos) {
				setErrorState(ParseErrorState.EMPTY_COLUMN);
				return -1;
			}
			reusable.setValue(neg ? -val : val);
			return i + delimiter.length;
		}
		if (bytes[i] < 48 || bytes[i] > 57) {
			setErrorState(ParseErrorState.NUMERIC_VALUE_ILLEGAL_CHARACTER);
			return -1;
		}
		val *= 10;
		val += bytes[i] - 48;

		// check for overflow / underflow
		if (val < 0) {
			// this is an overflow/underflow, unless we hit exactly the Long.MIN_VALUE
			if (neg && val == Long.MIN_VALUE) {
				reusable.setValue(Long.MIN_VALUE);
				
				if (i+1 >= limit) {
					return limit;
				} else if (i + 1 < delimLimit && delimiterNext(bytes, i + 1, delimiter)) {
					return i + 1 + delimiter.length;
				} else {
					setErrorState(ParseErrorState.NUMERIC_VALUE_OVERFLOW_UNDERFLOW);
					return -1;
				}
			}
			else {
				setErrorState(ParseErrorState.NUMERIC_VALUE_OVERFLOW_UNDERFLOW);
				return -1;
			}
		}
	}

	reusable.setValue(neg ? -val : val);
	return limit;
}
 

@Override
public LongValue reduce(LongValue value1, LongValue value2)
		throws Exception {
	value1.setValue(value1.getValue() + value2.getValue());
	return value1;
}
 

@Override
public LongValue reduce(LongValue value1, LongValue value2)
		throws Exception {
	value1.setValue(value1.getValue() + value2.getValue());
	return value1;
}