// for each assigned input split
while (!this.taskCanceled && splitIterator.hasNext())
{
// get start and end
final InputSplit split = splitIterator.next();
OT record = serializer.createInstance();
if (LOG.isDebugEnabled()) {
LOG.debug(getLogString("Opening input split " + split.toString()));
}
final InputFormat<OT, InputSplit> format = this.format;
// open input format
format.open(split);
if (LOG.isDebugEnabled()) {
LOG.debug(getLogString("Starting to read input from split " + split.toString()));
}
try {
// ======= special-case the Record, to help the JIT and avoid some casts ======
if (record.getClass() == Record.class) {
Record typedRecord = (Record) record;
@SuppressWarnings("unchecked")
final InputFormat<Record, InputSplit> inFormat = (InputFormat<Record, InputSplit>) format;
if (this.output instanceof RecordOutputCollector) {
// Record going directly into network channels
final RecordOutputCollector output = (RecordOutputCollector) this.output;
while (!this.taskCanceled && !inFormat.reachedEnd()) {
// build next pair and ship pair if it is valid
typedRecord.clear();
Record returnedRecord = null;
if ((returnedRecord = inFormat.nextRecord(typedRecord)) != null) {
output.collect(returnedRecord);
}
}
} else if (this.output instanceof ChainedCollectorMapDriver) {
// Record going to a chained map task
@SuppressWarnings("unchecked")
final ChainedCollectorMapDriver<Record, ?> output = (ChainedCollectorMapDriver<Record, ?>) this.output;
// as long as there is data to read
while (!this.taskCanceled && !inFormat.reachedEnd()) {
// build next pair and ship pair if it is valid
typedRecord.clear();
if ((typedRecord = inFormat.nextRecord(typedRecord)) != null) {
// This is where map of UDF gets called
output.collect(typedRecord);
}
}
} else {
// Record going to some other chained task
@SuppressWarnings("unchecked")
final Collector<Record> output = (Collector<Record>) this.output;
// as long as there is data to read
while (!this.taskCanceled && !inFormat.reachedEnd()) {
// build next pair and ship pair if it is valid
typedRecord.clear();
if ((typedRecord = inFormat.nextRecord(typedRecord)) != null){
output.collect(typedRecord);
}
}
}
} else {
// general types. we make a case distinction here for the common cases, in order to help
// JIT method inlining
if (this.output instanceof OutputCollector) {
final OutputCollector<OT> output = (OutputCollector<OT>) this.output;
// as long as there is data to read
while (!this.taskCanceled && !format.reachedEnd()) {
// build next pair and ship pair if it is valid
if ((record = format.nextRecord(record)) != null) {
output.collect(record);
}
}
} else if (this.output instanceof ChainedCollectorMapDriver) {
@SuppressWarnings("unchecked")
final ChainedCollectorMapDriver<OT, ?> output = (ChainedCollectorMapDriver<OT, ?>) this.output;
// as long as there is data to read
while (!this.taskCanceled && !format.reachedEnd()) {
// build next pair and ship pair if it is valid
if ((record = format.nextRecord(record)) != null) {
output.collect(record);
}
}
} else {
final Collector<OT> output = this.output;
// as long as there is data to read
while (!this.taskCanceled && !format.reachedEnd()) {
// build next pair and ship pair if it is valid
if ((record = format.nextRecord(record)) != null) {
output.collect(record);
}
}
}
}
if (LOG.isDebugEnabled() && !this.taskCanceled) {
LOG.debug(getLogString("Closing input split " + split.toString()));
}
} finally {
// close. We close here such that a regular close throwing an exception marks a task as failed.
format.close();
}