com.actelion.research.mapReduceGeneric.executors.MapReduceExecutorLocal Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of map-reduce-generic Show documentation
Generic Map Reduce Framework
There is a newer version: 1.0.10
/*
 *     Orbit, a versatile image analysis software for biological image-based quantification.
 *     Copyright (C) 2009 - 2016 Actelion Pharmaceuticals Ltd., Gewerbestrasse 16, CH-4123 Allschwil, Switzerland.
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program.  If not, see .
 *
 */

package com.actelion.research.mapReduceGeneric.executors;

import com.actelion.research.mapReduceGeneric.IMapReduce;
import com.actelion.research.mapReduceGeneric.utils.KeyValue;

import java.util.*;

/**
 * Executes mapReduce tasks, singe core. This is the simplest implementation of a mapReduce executor and perfect for testing.
 *
 * @param  Type Input (e.g. Integer for IDs)
 * @param  Output Key (measurement identifier)
 * @param  Output Value (e.g. Integer for a count)
 */
public class MapReduceExecutorLocal implements IMapReduceExecutor {

    private double progress = 0d;

    public Map execute(final Collection elements, final IMapReduce mapReduce) {
        long startTime = System.currentTimeMillis();
        setProgress(0d);
        // map
        List> keyValueList = new ArrayList>();
        for (T element : elements) {
            keyValueList.addAll(mapReduce.map(element));
        }

        setProgress(50d);
        // reduce
        Map> results = new HashMap>();
        for (KeyValue keyValue : keyValueList) {
            if (!results.containsKey(keyValue.getKey())) {
                results.put(keyValue.getKey(), new ArrayList());
            }
            results.get(keyValue.getKey()).add(keyValue.getValue());
        }

        setProgress(60d);
        final Map reduced = new HashMap();

        // map without results?
        if (results.keySet().size() == 0) {
            System.out.println("Warning: Map step returned no results");
            setProgress(100d);
            return reduced;
        }

        for (K key : results.keySet()) {
            reduced.put(key, mapReduce.reduce(key, results.get(key)));
        }

        setProgress(100d);
        double usedTime = (System.currentTimeMillis() - startTime) / 1000d;
        System.out.println("Used time: " + usedTime + " s");
        return reduced;
    }

    public double getProgress() {
        return progress;
    }

    public void setProgress(double progress) {
        this.progress = progress;
    }

    public void cancel() {
        // not implemented
    }

}