nus-yam/ex-repair huggingface dataset:
Program: 88347
Project: 88347
Buggy source:
/** 
 * @param channelID
 * @param requestQueue
 * @param buffers
 * @param filledBuffers
 * @throws IOException
 */
public ChannelWriter(Channel.ID channelID,RequestQueue<IORequest<Buffer.Output>> requestQueue,Collection<Buffer.Output> buffers,boolean filledBuffers) throws IOException {
  super(channelID,requestQueue,buffers);
  try {
    this.fileChannel.truncate(0);
  }
 catch (  IOException e) {
    throw new IOException("String_Node_Str" + channelID.getPath() + "String_Node_Str",e);
  }
  if (filledBuffers) {
    for (    Buffer.Output buffer : buffers) {
      this.requestQueue.add(new IORequest<Buffer.Output>(this,buffer));
    }
  }
 else {
    this.returnBuffers.addAll(buffers);
  }
  try {
    currentBuffer=nextBuffer();
    checkErroneous();
  }
 catch (  InterruptedException iex) {
    throw new IOException("String_Node_Str");
  }
}

Fixed version (ground truth):
/** 
 * @param channelID
 * @param requestQueue
 * @param buffers
 * @param filledBuffers
 * @throws IOException
 */
protected ChannelWriter(Channel.ID channelID,RequestQueue<IORequest<Buffer.Output>> requestQueue,Collection<Buffer.Output> buffers,boolean filledBuffers) throws IOException {
  super(channelID,requestQueue,buffers);
  try {
    this.fileChannel.truncate(0);
  }
 catch (  IOException e) {
    throw new IOException("String_Node_Str" + channelID.getPath() + "String_Node_Str",e);
  }
  if (filledBuffers) {
    for (    Buffer.Output buffer : buffers) {
      this.requestQueue.add(new IORequest<Buffer.Output>(this,buffer));
    }
  }
 else {
    this.returnBuffers.addAll(buffers);
  }
  try {
    currentBuffer=nextBuffer();
    checkErroneous();
  }
 catch (  InterruptedException iex) {
    throw new IOException("String_Node_Str");
  }
}
Program: 88348
Project: 88348
Buggy source:
/** 
 * <p> Creates a ChannelWriter for the anonymous file identified by the specified   {@code channelID} using the provided{@code memorySegments} as backing memory for an internal flow of output buffers. If the boolean variable {@code filled} is set, the content of the memorySegments is flushed to the file before reusing.</p>
 * @param channelID
 * @param freeSegments
 * @param filled
 * @return
 * @throws IOException
 */
public ChannelWriter createChannelWriter(Channel.ID channelID,Collection<Buffer.Output> buffers,boolean filled) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelWriter(channelID,writer.requestQueue,buffers,filled);
}

Fixed version (ground truth):
/** 
 * Creates a ChannelWriter for the anonymous file identified by the specified   {@code channelID} using the provided{@code memorySegments} as backing memory for an internal flow of output buffers. If the boolean variable {@code filled} is set, the content of the memorySegments is flushed to the file before reusing.
 * @param channelID
 * @param freeSegments
 * @param filled
 * @return
 * @throws IOException
 */
public ChannelWriter createChannelWriter(Channel.ID channelID,Collection<Buffer.Output> buffers,boolean filled) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelWriter(channelID,writer.requestQueue,buffers,filled);
}
Program: 88349
Project: 88349
Buggy source:
/** 
 * <p> Creates a ChannelWriter for the anonymous file written on secondary storage and identified by the specified  {@code channelID} using the provided {@code freeSegments} as backing memory for an internal flow of inputbuffers. </p>
 * @param channelID
 * @param freeSegments
 * @return
 * @throws IOException
 */
public ChannelReader createChannelReader(Channel.ID channelID,Collection<MemorySegment> freeSegments,boolean deleteFileAfterRead) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelReader(channelID,reader.requestQueue,createBuffer(Buffer.Type.INPUT,freeSegments),deleteFileAfterRead);
}

Fixed version (ground truth):
/** 
 * Creates a ChannelWriter for the anonymous file written on secondary storage and identified by the specified  {@code channelID} using the provided {@code freeSegments} as backing memory for an internal flow of inputbuffers.
 * @param channelID
 * @param freeSegments
 * @return
 * @throws IOException
 */
public ChannelReader createChannelReader(Channel.ID channelID,Collection<MemorySegment> freeSegments,boolean deleteFileAfterRead) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelReader(channelID,reader.requestQueue,createBuffer(Buffer.Type.INPUT,freeSegments),deleteFileAfterRead);
}
Program: 88350
Project: 88350
Buggy source:
/** 
 * Close method. Shuts down the reader and writer threads immediately, not waiting for their pending requests to be served. This method waits until the threads have actually ceased their operation.
 */
public synchronized final void shutdown(){
  if (!isClosed) {
    isClosed=true;
    LOG.info("String_Node_Str");
    try {
      writer.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      reader.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      this.writer.join();
      this.reader.join();
    }
 catch (    InterruptedException iex) {
    }
  }
}

Fixed version (ground truth):
/** 
 * Close method. Shuts down the reader and writer threads immediately, not waiting for their pending requests to be served. This method waits until the threads have actually ceased their operation.
 */
public synchronized final void shutdown(){
  if (!isClosed) {
    isClosed=true;
    try {
      writer.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      reader.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      this.writer.join();
      this.reader.join();
    }
 catch (    InterruptedException iex) {
    }
  }
}
Program: 88351
Project: 88351
Buggy source:
@Override public KeyValuePair<K,V> deserialize(DataInput in){
  try {
    KeyValuePair<K,V> pair=getInstance();
    pair.read(in);
    return pair;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
}

Fixed version (ground truth):
@Override public KeyValuePair<K,V> deserialize(DataInput in){
  try {
    KeyValuePair<K,V> pair=getInstance();
    pair.read(in);
    return pair;
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
}
Program: 88352
Project: 88352
Buggy source:
@Override public boolean next(){
  if (!iterator1.nextKey() || !iterator2.nextKey()) {
    return false;
  }
  K key1=iterator1.getKey();
  K key2=iterator2.getKey();
  while (key1.compareTo(key2) != 0) {
    if (key1.compareTo(key2) > 0) {
      if (!iterator2.nextKey()) {
        return false;
      }
      key2=iterator2.getKey();
    }
 else     if (key1.compareTo(key2) < 0) {
      if (!iterator1.nextKey()) {
        return false;
      }
      key1=iterator1.getKey();
    }
  }
  key=key1;
  return true;
}

Fixed version (ground truth):
@Override public V next(){
  return next.getValue();
}
Program: 88353
Project: 88353
Buggy source:
@Override public K getKey(){
  return key;
}

Fixed version (ground truth):
public K getKey(){
  return next.getKey();
}
Program: 88354
Project: 88354
Buggy source:
@Override public void open() throws IOException, MemoryAllocationException {
  final Comparator<K> keyComparator=new Comparator<K>(){
    @Override public int compare(    K k1,    K k2){
      return k1.compareTo(k2);
    }
  }
;
{
    final SerializationFactory<K> keySerialization=new WritableSerializationFactory<K>(keyClass);
    final SerializationFactory<V1> valSerialization=new WritableSerializationFactory<V1>(valueClass1);
    this.sortMerger1=new UnilateralSortMerger<K,V1>(memoryManager,ioManager,numSortBufferPerChannel,sizeSortBufferPerChannel,ioMemoryPerChannel,fileHandlesPerChannel,keySerialization,valSerialization,keyComparator,reader1,parentTask);
  }
{
    final SerializationFactory<K> keySerialization=new WritableSerializationFactory<K>(keyClass);
    final SerializationFactory<V2> valSerialization=new WritableSerializationFactory<V2>(valueClass2);
    this.sortMerger2=new UnilateralSortMerger<K,V2>(memoryManager,ioManager,numSortBufferPerChannel,sizeSortBufferPerChannel,ioMemoryPerChannel,fileHandlesPerChannel,keySerialization,valSerialization,keyComparator,reader2,parentTask);
  }
  this.iterator1=new KeyGroupedIterator<K,V1>(sortMerger1.getIterator());
  this.iterator2=new KeyGroupedIterator<K,V2>(sortMerger2.getIterator());
}

Fixed version (ground truth):
@Override public void open() throws IOException, MemoryAllocationException {
  final Comparator<K> keyComparator=new Comparator<K>(){
    @Override public int compare(    K k1,    K k2){
      return k1.compareTo(k2);
    }
  }
;
{
    final SerializationFactory<K> keySerialization=new WritableSerializationFactory<K>(keyClass);
    final SerializationFactory<V1> valSerialization=new WritableSerializationFactory<V1>(valueClass1);
    this.sortMerger1=new UnilateralSortMerger<K,V1>(memoryManager,ioManager,numSortBufferPerChannel,sizeSortBufferPerChannel,ioMemoryPerChannel,fileHandlesPerChannel,keySerialization,valSerialization,keyComparator,reader1,parentTask);
  }
{
    final SerializationFactory<K> keySerialization=new WritableSerializationFactory<K>(keyClass);
    final SerializationFactory<V2> valSerialization=new WritableSerializationFactory<V2>(valueClass2);
    this.sortMerger2=new UnilateralSortMerger<K,V2>(memoryManager,ioManager,numSortBufferPerChannel,sizeSortBufferPerChannel,ioMemoryPerChannel,fileHandlesPerChannel,keySerialization,valSerialization,keyComparator,reader2,parentTask);
  }
  this.iterator1=new KeyValueIterator<V1>(sortMerger1.getIterator());
  this.iterator2=new KeyValueIterator<V2>(sortMerger2.getIterator());
}
Program: 88355
Project: 88355
Buggy source:
@Override public byte[] writeLine(KeyValuePair<PactInteger,CoordVector> pair){
  StringBuilder line=new StringBuilder();
  DecimalFormat df=new DecimalFormat("String_Node_Str");
  line.append(pair.getKey().getValue());
  for (  double coord : pair.getValue().getCoordinates()) {
    line.append('|');
    line.append(df.format(coord));
  }
  line.append('|');
  line.append('\n');
  return line.toString().getBytes();
}

Fixed version (ground truth):
@Override public byte[] writeLine(KeyValuePair<PactInteger,CoordVector> pair){
  StringBuilder line=new StringBuilder();
  line.append(pair.getKey().getValue());
  for (  double coord : pair.getValue().getCoordinates()) {
    line.append('|');
    line.append(df.format(coord));
  }
  line.append('|');
  line.append('\n');
  return line.toString().getBytes();
}
Program: 88356
Project: 88356
Buggy source:
/** 
 * This method is periodically called by the framework to check the state of the task threads. If any task thread has unexpectedly switch to TERMINATED, this indicates that an   {@link Error} has occurredduring its execution.
 */
private void checkTaskExecution(){
synchronized (this.runningTasks) {
    final Iterator<ExecutionVertexID> it=this.runningTasks.keySet().iterator();
    while (it.hasNext()) {
      final ExecutionVertexID executionVertexID=it.next();
      final Environment environment=this.runningTasks.get(executionVertexID);
      if (environment.getExecutingThread().getState() == Thread.State.TERMINATED) {
        it.remove();
        environment.changeExecutionState(ExecutionState.FAILED,"String_Node_Str");
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * This method is periodically called by the framework to check the state of the task threads. If any task thread has unexpectedly switch to TERMINATED, this indicates that an   {@link Error} has occurredduring its execution.
 */
private void checkTaskExecution(){
  final List<Environment> crashEnvironments=new LinkedList<Environment>();
synchronized (this.runningTasks) {
    final Iterator<ExecutionVertexID> it=this.runningTasks.keySet().iterator();
    while (it.hasNext()) {
      final ExecutionVertexID executionVertexID=it.next();
      final Environment environment=this.runningTasks.get(executionVertexID);
      if (environment.getExecutingThread().getState() == Thread.State.TERMINATED) {
        it.remove();
        crashEnvironments.add(environment);
      }
    }
  }
  final Iterator<Environment> it2=crashEnvironments.iterator();
  while (it2.hasNext()) {
    it2.next().changeExecutionState(ExecutionState.FAILED,"String_Node_Str");
  }
}
Program: 88357
Project: 88357
Buggy source:
/** 
 * {@inheritDoc}
 */
@Override public TaskCancelResult cancelTask(ExecutionVertexID id) throws IOException {
  Environment tmpEnvironment;
synchronized (this.runningTasks) {
    tmpEnvironment=this.runningTasks.get(id);
    if (tmpEnvironment == null) {
      final TaskCancelResult taskCancelResult=new TaskCancelResult(id,AbstractTaskResult.ReturnCode.ERROR);
      taskCancelResult.setDescription("String_Node_Str" + id + "String_Node_Str");
      return taskCancelResult;
    }
  }
  final Environment environment=tmpEnvironment;
  Thread tmpThread=new Thread(new Runnable(){
    @Override public void run(){
      environment.cancelExecution();
    }
  }
);
  tmpThread.start();
  return new TaskCancelResult(id,AbstractTaskResult.ReturnCode.SUCCESS);
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public TaskCancelResult cancelTask(ExecutionVertexID id) throws IOException {
  Environment tmpEnvironment;
synchronized (this.runningTasks) {
    tmpEnvironment=this.runningTasks.get(id);
    if (tmpEnvironment == null) {
      final TaskCancelResult taskCancelResult=new TaskCancelResult(id,AbstractTaskResult.ReturnCode.ERROR);
      taskCancelResult.setDescription("String_Node_Str" + id + "String_Node_Str");
      return taskCancelResult;
    }
  }
  final Environment environment=tmpEnvironment;
  final Thread tmpThread=new Thread(new Runnable(){
    @Override public void run(){
      environment.cancelExecution();
    }
  }
);
  tmpThread.start();
  return new TaskCancelResult(id,AbstractTaskResult.ReturnCode.SUCCESS);
}
Program: 88358
Project: 88358
Buggy source:
public ChannelReader(Channel.ID channelID,RequestQueue<IORequest<Buffer.Input>> requestQueue,Collection<Buffer.Input> buffers) throws IOException {
  super(channelID,requestQueue,buffers);
  for (  Buffer.Input buffer : buffers) {
    this.requestQueue.add(new IORequest<Buffer.Input>(this,buffer));
  }
}

Fixed version (ground truth):
public ChannelReader(Channel.ID channelID,RequestQueue<IORequest<Buffer.Input>> requestQueue,Collection<Buffer.Input> buffers,boolean deleteWhenDone) throws IOException {
  super(channelID,requestQueue,buffers);
  this.deleteWhenDone=deleteWhenDone;
  for (  Buffer.Input buffer : buffers) {
    this.requestQueue.add(new IORequest<Buffer.Input>(this,buffer));
  }
}
Program: 88359
Project: 88359
Buggy source:
/** 
 * <p> Creates a ChannelWriter for the anonymous file identified by the specified   {@code channelID} using the provided{@code memorySegments} as backing memory for an internal flow of output buffers. If the boolean variable {@code filled} is set, the content of the memorySegments is flushed to the file before reusing.</p>
 * @param channelID
 * @param freeSegments
 * @param filled
 * @return
 * @throws ServiceException
 */
public ChannelWriter createChannelWriter(Channel.ID channelID,Collection<Buffer.Output> buffers,boolean filled) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelWriter(channelID,writer.requestQueue,buffers,filled);
}

Fixed version (ground truth):
/** 
 * <p> Creates a ChannelWriter for the anonymous file identified by the specified   {@code channelID} using the provided{@code memorySegments} as backing memory for an internal flow of output buffers. If the boolean variable {@code filled} is set, the content of the memorySegments is flushed to the file before reusing.</p>
 * @param channelID
 * @param freeSegments
 * @param filled
 * @return
 * @throws IOException
 */
public ChannelWriter createChannelWriter(Channel.ID channelID,Collection<Buffer.Output> buffers,boolean filled) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelWriter(channelID,writer.requestQueue,buffers,filled);
}
Program: 88360
Project: 88360
Buggy source:
/** 
 * <p> Creates a ChannelWriter for the anonymous file written on secondary storage and identified by the specified  {@code channelID} using the provided {@code freeSegments} as backing memory for an internal flow of inputbuffers. </p>
 * @param channelID
 * @param freeSegments
 * @return
 * @throws ServiceException
 */
public ChannelReader createChannelReader(Channel.ID channelID,Collection<MemorySegment> freeSegments) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelReader(channelID,reader.requestQueue,createBuffer(Buffer.Type.INPUT,freeSegments));
}

Fixed version (ground truth):
/** 
 * <p> Creates a ChannelWriter for the anonymous file written on secondary storage and identified by the specified  {@code channelID} using the provided {@code freeSegments} as backing memory for an internal flow of inputbuffers. </p>
 * @param channelID
 * @param freeSegments
 * @return
 * @throws IOException
 */
public ChannelReader createChannelReader(Channel.ID channelID,Collection<MemorySegment> freeSegments,boolean deleteFileAfterRead) throws IOException {
  if (isClosed) {
    throw new IllegalStateException("String_Node_Str");
  }
  return new ChannelReader(channelID,reader.requestQueue,createBuffer(Buffer.Type.INPUT,freeSegments),deleteFileAfterRead);
}
Program: 88361
Project: 88361
Buggy source:
/** 
 * Generic factory method for typed initialized collections of different buffer types.
 * @param < T >
 * @param bufferType
 * @param numberOfBuffers
 * @return Collection<T> an unsynchronized collection of initialized buffers
 * @throws ServiceException
 */
public static <T extends Buffer>Collection<T> createBuffer(Buffer.Type<T> bufferType,Collection<MemorySegment> freeSegments){
  ArrayList<T> buffers=new ArrayList<T>(freeSegments.size());
  for (  MemorySegment segment : freeSegments) {
    T buffer=createBuffer(bufferType);
    buffer.bind(segment);
    buffers.add(buffer);
  }
  return buffers;
}

Fixed version (ground truth):
/** 
 * Generic factory method for typed initialized collections of different buffer types.
 * @param < T >
 * @param bufferType
 * @param numberOfBuffers
 * @return Collection<T> an unsynchronized collection of initialized buffers
 */
public static <T extends Buffer>Collection<T> createBuffer(Buffer.Type<T> bufferType,Collection<MemorySegment> freeSegments){
  ArrayList<T> buffers=new ArrayList<T>(freeSegments.size());
  for (  MemorySegment segment : freeSegments) {
    T buffer=createBuffer(bufferType);
    buffer.bind(segment);
    buffers.add(buffer);
  }
  return buffers;
}
Program: 88362
Project: 88362
Buggy source:
/** 
 * Close method.
 */
public synchronized final void shutdown(){
  if (!isClosed) {
    isClosed=true;
    LOG.info("String_Node_Str");
    try {
      writer.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      reader.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      this.writer.join();
      this.reader.join();
    }
 catch (    InterruptedException iex) {
    }
  }
}

Fixed version (ground truth):
/** 
 * Close method. Shuts down the reader and writer threads immediately, not waiting for their pending requests to be served. This method waits until the threads have actually ceased their operation.
 */
public synchronized final void shutdown(){
  if (!isClosed) {
    isClosed=true;
    LOG.info("String_Node_Str");
    try {
      writer.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      reader.shutdown();
    }
 catch (    Throwable t) {
      LOG.error("String_Node_Str",t);
    }
    try {
      this.writer.join();
      this.reader.join();
    }
 catch (    InterruptedException iex) {
    }
  }
}
Program: 88363
Project: 88363
Buggy source:
public boolean isProperlyShutDown(){
  return isClosed && (this.writer.getState() == Thread.State.TERMINATED) && (this.reader.getState() == Thread.State.TERMINATED);
}

Fixed version (ground truth):
/** 
 * Utility method to check whether the IO manager has been properly shut down. The IO manager is considered to be properly shut down when it is closed and its threads have ceased operation.
 * @return True, if the IO manager has properly shut down, false otherwise.
 */
public boolean isProperlyShutDown(){
  return isClosed && (this.writer.getState() == Thread.State.TERMINATED) && (this.reader.getState() == Thread.State.TERMINATED);
}
Program: 88364
Project: 88364
Buggy source:
private int readFromChannel(Channel.ID channelID) throws IOException, MemoryAllocationException {
  Collection<MemorySegment> freeSegments=memoryManager.allocate(new DummyInvokable(),NUMBER_OF_SEGMENTS,SEGMENT_SIZE);
  ChannelReader channelReader=ioManager.createChannelReader(channelID,freeSegments);
  generator.reset();
  Value value=new Value();
  int readCounter=0;
  while (channelReader.read(value)) {
    Assert.assertEquals("String_Node_Str",generator.next(),value);
    readCounter++;
  }
  memoryManager.release(channelReader.close());
  return readCounter;
}

Fixed version (ground truth):
private int readFromChannel(Channel.ID channelID) throws IOException, MemoryAllocationException {
  Collection<MemorySegment> freeSegments=memoryManager.allocate(new DummyInvokable(),NUMBER_OF_SEGMENTS,SEGMENT_SIZE);
  ChannelReader channelReader=ioManager.createChannelReader(channelID,freeSegments,true);
  generator.reset();
  Value value=new Value();
  int readCounter=0;
  while (channelReader.read(value)) {
    Assert.assertEquals("String_Node_Str",generator.next(),value);
    readCounter++;
  }
  memoryManager.release(channelReader.close());
  return readCounter;
}
Program: 88365
Project: 88365
Buggy source:
/** 
 * This utility method picks the instance type to be used for scheduling PACT processor instances.
 * @param types The available types.
 * @return The type to be used for scheduling.
 */
private InstanceTypeDescription getType(Map<InstanceType,InstanceTypeDescription> types){
  if (types == null || types.size() < 1) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  long minMemory=0;
  int minCPUCores=Integer.MAX_VALUE;
  InstanceTypeDescription retValue=null;
  final Iterator<InstanceTypeDescription> it=types.values().iterator();
  while (it.hasNext()) {
    final InstanceTypeDescription descr=it.next();
    if (retValue == null) {
      retValue=descr;
    }
    if (descr.getInstanceType().getNumberOfCores() < minCPUCores && descr.getHardwareDescription().getSizeOfFreeMemory() > minMemory) {
      minCPUCores=descr.getInstanceType().getNumberOfCores();
      minMemory=descr.getHardwareDescription().getSizeOfFreeMemory();
      retValue=descr;
    }
  }
  return retValue;
}

Fixed version (ground truth):
/** 
 * This utility method picks the instance type to be used for scheduling PACT processor instances. <p>
 * @param types The available types.
 * @return The type to be used for scheduling.
 * @throws CompilerException
 * @throws IllegalArgumentException
 */
private InstanceTypeDescription getType(Map<InstanceType,InstanceTypeDescription> types) throws CompilerException {
  if (types == null || types.size() < 1) {
    throw new IllegalArgumentException("String_Node_Str");
  }
  InstanceTypeDescription retValue=null;
  long totalMemory=0;
  int numInstances=0;
  final Iterator<InstanceTypeDescription> it=types.values().iterator();
  while (it.hasNext()) {
    final InstanceTypeDescription descr=it.next();
    if (descr.getHardwareDescription() == null || descr.getInstanceType() == null) {
      continue;
    }
    final int curInstances=descr.getMaximumNumberOfAvailableInstances();
    final long curMemory=curInstances * descr.getHardwareDescription().getSizeOfFreeMemory();
    if ((retValue == null) || (curInstances > numInstances && (int)(curMemory * 1.2f) > totalMemory) || (curInstances * retValue.getInstanceType().getNumberOfCores() >= numInstances && (int)(curMemory * 1.5f) > totalMemory)) {
      retValue=descr;
      numInstances=curInstances;
      totalMemory=curMemory;
    }
  }
  if (retValue == null) {
    throw new CompilerException("String_Node_Str" + "String_Node_Str");
  }
  return retValue;
}
Program: 88366
Project: 88366
Buggy source:
@Override public boolean next() throws IOException, InterruptedException {
  KeyValuePair<K,VP> pair=probePairSerialization.newInstance();
  while (currentProbePartitionReader.read(pair)) {
    K key=pair.getKey();
    if (hashMap.contains(key)) {
      currentKey=key;
      currentBuildValuesIterable=hashMap.get(currentKey);
      currentProbeValuesIterable.value=pair.getValue();
      return true;
    }
  }
  if (currentPartition >= numberOfPartitions - 1) {
    return false;
  }
  try {
    currentProbePartitionReader.close();
    currentPartition++;
    LOG.debug("String_Node_Str" + currentPartition);
    hashMap.clear();
    currentBuildPartitionReader=ioManager.createChannelReader(buildPartitionIDs.get(currentPartition),freeSegments);
    KeyValuePair<K,VB> tmp=buildPairSerialization.newInstance();
    while (currentBuildPartitionReader.read(tmp)) {
      hashMap.put(tmp.getKey(),tmp.getValue());
      tmp=buildPairSerialization.newInstance();
    }
    currentBuildPartitionReader.close();
    currentProbePartitionReader=ioManager.createChannelReader(probePartitionIDs.get(currentPartition),freeSegments);
    return next();
  }
 catch (  ServiceException e) {
    throw new IOException(e);
  }
catch (  Exception e) {
    throw new IOException(e);
  }
}

Fixed version (ground truth):
@Override public boolean next() throws IOException, InterruptedException {
  KeyValuePair<K,VP> pair=probePairSerialization.newInstance();
  while (currentProbePartitionReader.read(pair)) {
    K key=pair.getKey();
    if (hashMap.contains(key)) {
      currentKey=key;
      currentBuildValuesIterable=hashMap.get(currentKey);
      currentProbeValuesIterable.value=pair.getValue();
      return true;
    }
  }
  if (currentPartition >= numberOfPartitions - 1) {
    return false;
  }
  try {
    currentProbePartitionReader.close();
    currentPartition++;
    LOG.debug("String_Node_Str" + currentPartition);
    hashMap.clear();
    currentBuildPartitionReader=ioManager.createChannelReader(buildPartitionIDs.get(currentPartition),freeSegments,false);
    KeyValuePair<K,VB> tmp=buildPairSerialization.newInstance();
    while (currentBuildPartitionReader.read(tmp)) {
      hashMap.put(tmp.getKey(),tmp.getValue());
      tmp=buildPairSerialization.newInstance();
    }
    currentBuildPartitionReader.close();
    currentProbePartitionReader=ioManager.createChannelReader(probePartitionIDs.get(currentPartition),freeSegments,false);
    return next();
  }
 catch (  ServiceException e) {
    throw new IOException(e);
  }
catch (  Exception e) {
    throw new IOException(e);
  }
}
Program: 88367
Project: 88367
Buggy source:
/** 
 * Repartitions the build side.
 * @throws IOException
 * @throws InterruptedException
 * @throws ServiceException
 */
private void repartitionBuildSide() throws IOException, InterruptedException, ServiceException {
  LOG.debug("String_Node_Str");
  KeyValuePair<K,VB> pair=buildPairSerialization.newInstance();
  int partition;
  for (  K key : hashMap.keys()) {
    partition=partitioner.getPartition(key);
    for (    VB value : hashMap.get(key)) {
      partitionWriters.get(partition).write(new KeyValuePair<K,VB>(key,value));
    }
  }
  hashMap.clear();
  ChannelReader partitionZeroReader=ioManager.createChannelReader(buildPartitionIDs.get(0),partitionWriters.get(0).close());
  while (partitionZeroReader.read(pair)) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
  partitionWriters.set(0,ioManager.createChannelWriter(buildPartitionIDs.get(0),partitionZeroReader.close()));
  LOG.debug("String_Node_Str");
  pair=overflowCause;
  partition=partitioner.getPartition(pair.getKey());
  if (partition == 0) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
 else {
    partitionWriters.get(partition).write(pair);
  }
  LOG.debug("String_Node_Str");
  while (readerBuild.hasNext()) {
    pair=readerBuild.next();
    partition=partitioner.getPartition(pair.getKey());
    if (partition == 0) {
      hashMap.put(pair.getKey(),pair.getValue());
    }
 else {
      partitionWriters.get(partition).write(pair);
    }
  }
}

Fixed version (ground truth):
/** 
 * Repartitions the build side.
 * @throws IOException
 * @throws InterruptedException
 * @throws ServiceException
 */
private void repartitionBuildSide() throws IOException, InterruptedException, ServiceException {
  LOG.debug("String_Node_Str");
  KeyValuePair<K,VB> pair=buildPairSerialization.newInstance();
  int partition;
  for (  K key : hashMap.keys()) {
    partition=partitioner.getPartition(key);
    for (    VB value : hashMap.get(key)) {
      partitionWriters.get(partition).write(new KeyValuePair<K,VB>(key,value));
    }
  }
  hashMap.clear();
  ChannelReader partitionZeroReader=ioManager.createChannelReader(buildPartitionIDs.get(0),partitionWriters.get(0).close(),false);
  while (partitionZeroReader.read(pair)) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
  partitionWriters.set(0,ioManager.createChannelWriter(buildPartitionIDs.get(0),partitionZeroReader.close()));
  LOG.debug("String_Node_Str");
  pair=overflowCause;
  partition=partitioner.getPartition(pair.getKey());
  if (partition == 0) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
 else {
    partitionWriters.get(partition).write(pair);
  }
  LOG.debug("String_Node_Str");
  while (readerBuild.hasNext()) {
    pair=readerBuild.next();
    partition=partitioner.getPartition(pair.getKey());
    if (partition == 0) {
      hashMap.put(pair.getKey(),pair.getValue());
    }
 else {
      partitionWriters.get(partition).write(pair);
    }
  }
}
Program: 88368
Project: 88368
Buggy source:
@Override public void initialize() throws ServiceException, IOException, InterruptedException {
  LOG.debug("String_Node_Str");
  numberOfPartitions=freeSegments.size() / 2;
  partitioner=new Partitioner(numberOfPartitions);
  partitionWriters=new ArrayList<ChannelWriter>(numberOfPartitions);
  buildPartitionIDs=new ArrayList<Channel.ID>(numberOfPartitions);
  probePartitionIDs=new ArrayList<Channel.ID>(numberOfPartitions);
  LOG.debug("String_Node_Str" + numberOfPartitions + "String_Node_Str");
  LOG.debug("String_Node_Str");
  Channel.Enumerator buildEnumerator=ioManager.createChannelEnumerator();
  allocatePartitionWriters(buildEnumerator,buildPartitionIDs);
  repartitionBuildSide();
  closePartitionWriters();
  LOG.debug("String_Node_Str");
  Channel.Enumerator probeEnumerator=ioManager.createChannelEnumerator();
  allocatePartitionWriters(probeEnumerator,probePartitionIDs);
  repartitionProbeSide();
  closePartitionWriters();
  currentPartition=0;
  currentBuildPartitionReader=ioManager.createChannelReader(buildPartitionIDs.get(currentPartition),freeSegments);
  KeyValuePair<K,VB> pair=buildPairSerialization.newInstance();
  while (currentBuildPartitionReader.read(pair)) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
  currentBuildPartitionReader.close();
  currentProbePartitionReader=ioManager.createChannelReader(probePartitionIDs.get(currentPartition),freeSegments);
}

Fixed version (ground truth):
@Override public void initialize() throws ServiceException, IOException, InterruptedException {
  LOG.debug("String_Node_Str");
  numberOfPartitions=freeSegments.size() / 2;
  partitioner=new Partitioner(numberOfPartitions);
  partitionWriters=new ArrayList<ChannelWriter>(numberOfPartitions);
  buildPartitionIDs=new ArrayList<Channel.ID>(numberOfPartitions);
  probePartitionIDs=new ArrayList<Channel.ID>(numberOfPartitions);
  LOG.debug("String_Node_Str" + numberOfPartitions + "String_Node_Str");
  LOG.debug("String_Node_Str");
  Channel.Enumerator buildEnumerator=ioManager.createChannelEnumerator();
  allocatePartitionWriters(buildEnumerator,buildPartitionIDs);
  repartitionBuildSide();
  closePartitionWriters();
  LOG.debug("String_Node_Str");
  Channel.Enumerator probeEnumerator=ioManager.createChannelEnumerator();
  allocatePartitionWriters(probeEnumerator,probePartitionIDs);
  repartitionProbeSide();
  closePartitionWriters();
  currentPartition=0;
  currentBuildPartitionReader=ioManager.createChannelReader(buildPartitionIDs.get(currentPartition),freeSegments,false);
  KeyValuePair<K,VB> pair=buildPairSerialization.newInstance();
  while (currentBuildPartitionReader.read(pair)) {
    hashMap.put(pair.getKey(),pair.getValue());
  }
  currentBuildPartitionReader.close();
  currentProbePartitionReader=ioManager.createChannelReader(probePartitionIDs.get(currentPartition),freeSegments,false);
}
Program: 88369
Project: 88369
Buggy source:
public void reset(){
  try {
    next=null;
    if (fitsIntoMem) {
      if (currentBuffer != usedBuffers)       inputBuffers.get(currentBuffer).reset();
      currentBuffer=0;
    }
 else {
      ioReader.close();
      ioReader=ioManager.createChannelReader(bufferID,memorySegments);
    }
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
  LOG.debug("String_Node_Str" + count + "String_Node_Str");
  count=0;
}

Fixed version (ground truth):
public void reset(){
  try {
    next=null;
    if (fitsIntoMem) {
      if (currentBuffer != usedBuffers)       inputBuffers.get(currentBuffer).reset();
      currentBuffer=0;
    }
 else {
      ioReader.close();
      ioReader=ioManager.createChannelReader(bufferID,memorySegments,false);
    }
  }
 catch (  IOException e) {
    throw new RuntimeException(e);
  }
  LOG.debug("String_Node_Str" + count + "String_Node_Str");
  count=0;
}
Program: 88376
Project: 88376
Buggy source:
/** 
 * Entry point of the thread.
 */
public void go() throws Exception {
  final Channel.Enumerator enumerator=ioManager.createChannelEnumerator();
  List<Channel.ID> channelIDs=new ArrayList<Channel.ID>();
  Collection<MemorySegment> outputSegments=memoryManager.allocate(UnilateralSortMerger.this.parent,2,ioMemorySize / 2);
  freeSegmentsAtShutdown(outputSegments);
  CircularElement element=null;
  while (isRunning() && (element=queues.spill.take()) != SENTINEL) {
    Channel.ID channel=enumerator.next();
    channelIDs.add(channel);
    ChannelWriter writer=ioManager.createChannelWriter(channel,outputSegments);
    LOG.debug("String_Node_Str" + element.id + "String_Node_Str");
    element.buffer.writeToChannel(writer);
    LOG.debug("String_Node_Str" + element.id + "String_Node_Str");
    outputSegments=writer.close();
    element.buffer.reset();
    queues.empty.put(element);
  }
  LOG.debug("String_Node_Str");
  LOG.debug("String_Node_Str");
  memoryManager.release(outputSegments);
  LOG.debug("String_Node_Str");
  while (!queues.empty.isEmpty()) {
    memoryManager.release(queues.empty.take().buffer.unbind());
  }
  while (channelIDs.size() > maxNumFileHandles) {
    channelIDs=mergeChannelList(channelIDs,ioMemorySize);
  }
  lazyIterator.setTarget(getMergingIterator(channelIDs,ioMemorySize));
  LOG.debug("String_Node_Str");
}

Fixed version (ground truth):
/** 
 * Entry point of the thread.
 */
public void go() throws Exception {
  final Channel.Enumerator enumerator=ioManager.createChannelEnumerator();
  List<Channel.ID> channelIDs=new ArrayList<Channel.ID>();
  outputSegments=memoryManager.allocate(UnilateralSortMerger.this.parent,2,ioMemorySize / 2);
  freeSegmentsAtShutdown(outputSegments);
  CircularElement element=null;
  while (isRunning() && (element=queues.spill.take()) != SENTINEL) {
    Channel.ID channel=enumerator.next();
    channelIDs.add(channel);
    ChannelWriter writer=ioManager.createChannelWriter(channel,outputSegments);
    LOG.debug("String_Node_Str" + element.id + "String_Node_Str");
    element.buffer.writeToChannel(writer);
    LOG.debug("String_Node_Str" + element.id + "String_Node_Str");
    outputSegments=writer.close();
    element.buffer.reset();
    queues.empty.put(element);
  }
  LOG.debug("String_Node_Str");
  LOG.debug("String_Node_Str");
  memoryManager.release(outputSegments);
  LOG.debug("String_Node_Str");
  while (!queues.empty.isEmpty()) {
    memoryManager.release(queues.empty.take().buffer.unbind());
  }
  while (channelIDs.size() > maxNumFileHandles) {
    channelIDs=mergeChannelList(channelIDs,ioMemorySize);
  }
  lazyIterator.setTarget(getMergingIterator(channelIDs,ioMemorySize));
  LOG.debug("String_Node_Str");
}
Program: 88377
Project: 88377
Buggy source:
/** 
 * Forces an immediate shutdown of the thread. Looses any state and all buffers that the thread is currently working on. This terminates cleanly for the JVM, but looses intermediate results.
 */
public void shutdown(){
  this.alive=false;
  this.interrupt();
}

Fixed version (ground truth):
@Override public void shutdown(){
  this.memoryManager.release(outputSegments);
  super.shutdown();
}
Program: 88378
Project: 88378
Buggy source:
/** 
 * Assigns the execution vertex with an   {@link AllocatedResource}.
 * @param allocatedResource the resources which are supposed to be allocated to this vertex
 */
public synchronized void setAllocatedResource(AllocatedResource allocatedResource){
  this.allocatedResource=allocatedResource;
}

Fixed version (ground truth):
/** 
 * Assigns the execution vertex with an   {@link AllocatedResource}.
 * @param allocatedResource the resources which are supposed to be allocated to this vertex
 */
public synchronized void setAllocatedResource(AllocatedResource allocatedResource){
  this.allocatedResource=allocatedResource;
  final Iterator<VertexAssignmentListener> it=this.vertexAssignmentListeners.iterator();
  while (it.hasNext()) {
    it.next().vertexAssignmentChanged(this.vertexID,this.allocatedResource);
  }
}
Program: 88379
Project: 88379
Buggy source:
/** 
 * Registers a job in form of its execution graph representation with the job progress collector. The collector will subscribe to state changes of the individual subtasks. A separate deregistration is not necessary since the job progress collector periodically discards outdated progress information.
 * @param executionGraph the execution graph representing the job
 * @param profilingAvailable indicates if profiling data is available for this job
 */
public void registerJob(ExecutionGraph executionGraph,boolean profilingAvailable){
  final Iterator<ExecutionVertex> it=new ExecutionGraphIterator(executionGraph,true);
  while (it.hasNext()) {
    final ExecutionVertex vertex=it.next();
    vertex.getEnvironment().registerExecutionListener(new ExecutionListenerWrapper(this,vertex.getGroupVertex().getJobVertexID(),vertex.getID()));
  }
  executionGraph.registerJobStatusListener(new JobStatusListenerWrapper(this,executionGraph.getJobName(),profilingAvailable));
}

Fixed version (ground truth):
/** 
 * Registers a job in form of its execution graph representation with the job progress collector. The collector will subscribe to state changes of the individual subtasks. A separate deregistration is not necessary since the job progress collector periodically discards outdated progress information.
 * @param executionGraph the execution graph representing the job
 * @param profilingAvailable indicates if profiling data is available for this job
 */
public void registerJob(ExecutionGraph executionGraph,boolean profilingAvailable){
  final Iterator<ExecutionVertex> it=new ExecutionGraphIterator(executionGraph,true);
  while (it.hasNext()) {
    final ExecutionVertex vertex=it.next();
    vertex.getEnvironment().registerExecutionListener(new ExecutionListenerWrapper(this,vertex.getGroupVertex().getJobVertexID(),vertex.getID()));
    vertex.registerVertexAssignmentListener(new VertexAssignmentListenerWrapper(this,executionGraph.getJobID()));
  }
  executionGraph.registerJobStatusListener(new JobStatusListenerWrapper(this,executionGraph.getJobName(),profilingAvailable));
}
Program: 88380
Project: 88380
Buggy source:
@Override public void processProfilingEvents(ProfilingEvent profilingEvent){
  addEvent(profilingEvent.getJobID(),profilingEvent);
}

Fixed version (ground truth):
/** 
 * {@inheritDoc}
 */
@Override public void processProfilingEvents(ProfilingEvent profilingEvent){
  addEvent(profilingEvent.getJobID(),profilingEvent);
}
Program: 88381
Project: 88381
Buggy source:
public void updateView(){
  if (this.threadChart != null) {
    this.threadChart.getChart().getXYPlot().configureDomainAxes();
    this.threadChart.getChart().fireChartChanged();
  }
  this.executionStateLabel.setText(this.managementVertex.getExecutionState().toString());
  final ManagementGroupVertex groupVertex=this.managementVertex.getGroupVertex();
  final GroupVertexVisualizationData groupVertexVisualizationData=(GroupVertexVisualizationData)groupVertex.getAttachment();
  if (groupVertexVisualizationData.isCPUBottleneck()) {
    if (this.warningComposite == null) {
      this.warningComposite=createWarningComposite(WARNINGTEXT,SWT.ICON_WARNING);
      Rectangle clientRect=getShell().getClientArea();
      clientRect.height+=ICONSIZE;
      getShell().setSize(clientRect.width,clientRect.height);
    }
  }
 else {
    if (this.warningComposite != null) {
      this.warningComposite.dispose();
      this.warningComposite=null;
      Rectangle clientRect=getShell().getClientArea();
      clientRect.height-=ICONSIZE;
      getShell().setSize(clientRect.width,clientRect.height);
    }
  }
}

Fixed version (ground truth):
public void updateView(){
  if (this.threadChart != null) {
    this.threadChart.getChart().getXYPlot().configureDomainAxes();
    this.threadChart.getChart().fireChartChanged();
  }
  this.executionStateLabel.setText(this.managementVertex.getExecutionState().toString());
  this.instanceIDLabel.setText(this.managementVertex.getInstanceName());
  this.instanceTypeLabel.setText(this.managementVertex.getInstanceType());
  final ManagementGroupVertex groupVertex=this.managementVertex.getGroupVertex();
  final GroupVertexVisualizationData groupVertexVisualizationData=(GroupVertexVisualizationData)groupVertex.getAttachment();
  if (groupVertexVisualizationData.isCPUBottleneck()) {
    if (this.warningComposite == null) {
      this.warningComposite=createWarningComposite(WARNINGTEXT,SWT.ICON_WARNING);
      Rectangle clientRect=getShell().getClientArea();
      clientRect.height+=ICONSIZE;
      getShell().setSize(clientRect.width,clientRect.height);
    }
  }
 else {
    if (this.warningComposite != null) {
      this.warningComposite.dispose();
      this.warningComposite=null;
      Rectangle clientRect=getShell().getClientArea();
      clientRect.height-=ICONSIZE;
      getShell().setSize(clientRect.width,clientRect.height);
    }
  }
}
Program: 88383
Project: 88383
Buggy source:
protected JobGraph getJobGraph() throws Exception {
  JobGraph jobGraph=new JobGraph("String_Node_Str");
  JobFileInputVertex input=new JobFileInputVertex("String_Node_Str",jobGraph);
  input.setFileInputClass(FileLineReader.class);
  input.setFilePath(new Path(hdfs.getTempDirPath() + "String_Node_Str"));
  JobTaskVertex task=new JobTaskVertex("String_Node_Str",jobGraph);
  task.setTaskClass(GrepTask.class);
  JobFileOutputVertex output=new JobFileOutputVertex("String_Node_Str",jobGraph);
  output.setFileOutputClass(FileLineWriter.class);
  output.setFilePath(new Path(hdfs.getTempDirPath() + "String_Node_Str"));
  input.connectTo(task,ChannelType.INMEMORY,CompressionLevel.NO_COMPRESSION);
  task.connectTo(output,ChannelType.INMEMORY,CompressionLevel.NO_COMPRESSION);
  return jobGraph;
}

Fixed version (ground truth):
protected JobGraph getJobGraph() throws Exception {
  JobGraph jobGraph=new JobGraph("String_Node_Str");
  JobFileInputVertex input=new JobFileInputVertex("String_Node_Str",jobGraph);
  input.setFileInputClass(FileLineReader.class);
  input.setFilePath(new Path(hdfs.getURIPrefix() + hdfs.getTempDirPath() + "String_Node_Str"));
  JobTaskVertex task=new JobTaskVertex("String_Node_Str",jobGraph);
  task.setTaskClass(GrepTask.class);
  JobFileOutputVertex output=new JobFileOutputVertex("String_Node_Str",jobGraph);
  output.setFileOutputClass(FileLineWriter.class);
  output.setFilePath(new Path(hdfs.getURIPrefix() + hdfs.getTempDirPath() + "String_Node_Str"));
  input.connectTo(task,ChannelType.INMEMORY,CompressionLevel.NO_COMPRESSION);
  task.connectTo(output,ChannelType.INMEMORY,CompressionLevel.NO_COMPRESSION);
  return jobGraph;
}
Program: 88384
Project: 88384
Buggy source:
protected void preSubmit() throws Exception {
  OutputStream os=hdfs.getOutputStream("String_Node_Str");
  Writer wr=new OutputStreamWriter(os);
  wr.write("String_Node_Str");
  wr.write("String_Node_Str");
  wr.write("String_Node_Str");
  wr.close();
}

Fixed version (ground truth):
protected void preSubmit() throws Exception {
  OutputStream os=hdfs.getOutputStream(hdfs.getTempDirPath() + "String_Node_Str");
  Writer wr=new OutputStreamWriter(os);
  wr.write("String_Node_Str");
  wr.write("String_Node_Str");
  wr.write("String_Node_Str");
  wr.close();
}
Program: 88385
Project: 88385
Buggy source:
/** 
 * Verifies that at least one InputSplit was assigned to each vertex
 * @throws ExecutionFailureException
 */
private void verifyAssignments() throws ExecutionFailureException {
  while (this.vertexPrioQueue.size() > 0) {
    QueueElem topElem=this.vertexPrioQueue.poll();
    if (topElem.getNoAssignedSplits() == 0) {
      throw new ExecutionFailureException("String_Node_Str" + topElem.getVertex().getName() + "String_Node_Str"+ topElem.getVertex().getAllocatedResource().getInstance().getInstanceConnectionInfo().getHostName()+ "String_Node_Str"+ topElem.getVertex().getID()+ "String_Node_Str");
    }
    LOG.info(topElem.getNoAssignedSplits() + "String_Node_Str" + topElem.getVertex().getAllocatedResource().getInstance().getInstanceConnectionInfo().getHostName());
    for (    InputSplit is : topElem.getVertex().getEnvironment().getInputSplits()) {
      LOG.info("String_Node_Str" + ((FileInputSplit)is).getPath());
      for (      String hn : is.getHostNames()) {
        LOG.info("String_Node_Str" + hn);
      }
    }
  }
}

Fixed version (ground truth):
/** 
 * Verifies that at least one InputSplit was assigned to each vertex
 * @throws ExecutionFailureException
 */
private void verifyAssignments() throws ExecutionFailureException {
  while (this.vertexPrioQueue.size() > 0) {
    final QueueElem topElem=this.vertexPrioQueue.poll();
    if (topElem.getNoAssignedSplits() == 0) {
      continue;
    }
    LOG.info(topElem.getNoAssignedSplits() + "String_Node_Str" + topElem.getVertex().getAllocatedResource().getInstance().getInstanceConnectionInfo().getHostName());
    for (    InputSplit is : topElem.getVertex().getEnvironment().getInputSplits()) {
      LOG.info("String_Node_Str" + ((FileInputSplit)is).getPath());
      for (      String hn : is.getHostNames()) {
        LOG.info("String_Node_Str" + hn);
      }
    }
  }
}