CaFactory.cpp

Go to the documentation of this file.

/*
 * Copyright (C) 2009 Kamil Dudka <xdudka00@stud.fit.vutbr.cz>
 *
 * This file is part of nucad (Non-Uniform CA Designer).
 *
 * nucad 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
 * any later version.
 *
 * nucad 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 nucad.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"
#include "CaFactory.h"
#include "Ca.h"
#include "Color.h"

#ifndef BUILDING_DOX
#   include <map>
#   include <set>
#   include <stdexcept>
#   include <sstream>

#   define DOX_FAKE_PARENT(PARENT)
#else
#   define DOX_FAKE_PARENT(PARENT) : public PARENT
#endif

#ifndef GF_INCLUDE_TRIVIAL
#   define GF_INCLUDE_TRIVIAL 0
#endif

#ifndef GF_INCLUDE_COMPLEX
#   define GF_INCLUDE_COMPLEX 0
#endif

struct DefParams: public CaEvalParams {
    DefParams() {
        caSize = 5;
        nSteps = 6;
    }
};

template <int N_IN, int N_OUT>
struct Binder
{
    /* no tag - this will fail intentionally */
};

template <> struct Binder<2,1> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 1, 0,
            BindInput<1, 3, 0,
            BindOutput<0, 2, 4>
            > > tag;
};

template <> struct Binder<3,1> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 0, 0,
            BindInput<1, 2, 0,
            BindInput<2, 4, 0,
            BindOutput<0, 2, 4>
            > > > tag;
};

template <> struct Binder<5,1> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 0, 0,
            BindInput<1, 1, 0,
            BindInput<2, 2, 0,
            BindInput<3, 3, 0,
            BindInput<4, 4, 0,
            BindOutput<0, 2, 4>
            > > > > > tag;
};

template <> struct Binder<2,2> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 1, 0,
            BindInput<1, 3, 0,
            BindOutput<0, 1, 4,
            BindOutput<1, 3, 4>
            > > > tag;
};

template <> struct Binder<3,3> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 0, 0,
            BindInput<1, 2, 0,
            BindInput<2, 4, 0,
            BindOutput<0, 0, 4,
            BindOutput<1, 2, 4,
            BindOutput<2, 4, 4>
            > > > > > tag;
};

template <> struct Binder<4,4> DOX_FAKE_PARENT(Binder)
{
    typedef BindInput<0, 0, 1,
            BindInput<1, 0, 3,
            BindInput<2, 1, 0,
            BindInput<3, 3, 0,
            BindOutput<0, 4, 3,
            BindOutput<1, 4, 1,
            BindOutput<2, 3, 4,
            BindOutput<3, 1, 4>
            > > > > > > > tag;
};

template <class CIRCUIT, class BINDING, class PARAMS = DefParams>
class PrivateFactory {
    public:
        static CaEvaluator* create() {
            return new CaEvaluator(CIRCUIT(), BINDING(), PARAMS());
        }
};

template <template <int> class GATE, int N>
class GateFactory {
    public:
        typedef GATE<N>                                 TGate;
        typedef typename Binder<N,1>::tag               TBinding;

    public:
        static CaEvaluator* create() {
            return PrivateFactory<TGate, TBinding>::create();
        }

    private:
        CT_ASSERT<TBinding::BOUND_INPUTS + 1 == 1 << N>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_INPUT_BINDING_FOR_GATE___;

        CT_ASSERT<TBinding::BOUND_OUTPUTS == 1>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_OUTPUT_BINDING_FOR_GATE___;
};

template <int N, template <int> class GATE = CrossGate>
class WireCrossFactory {
    public:
        typedef GATE<N>                                 TGate;
        typedef typename Binder<N,N>::tag               TBinding;

    public:
        static CaEvaluator* create() {
            return PrivateFactory<TGate, TBinding>::create();
        }

    private:
        CT_ASSERT<TBinding::BOUND_INPUTS + 1 == 1 << N>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_INPUT_BINDING_FOR_CROSS___;

        CT_ASSERT<TBinding::BOUND_OUTPUTS + 1 == 1 << N>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_OUTPUT_BINDING_FOR_CROSS___;
};

template <int N> class MuxGate;

template <>
class MuxGate<3>: public AbstractGate<3,1> {
    public:
        virtual IGate* clone() const {
            return new MuxGate(*this);
        }
        virtual TBus operator[] (TBus in) const {
            bool result = (in & 4)
                ? (in & 2)
                : (in & 1);
            return result;
        }
};

template <>
class MuxGate<6>: public AbstractGate<6,1> {
    public:
        virtual IGate* clone() const {
            return new MuxGate(*this);
        }
        virtual TBus operator[] (TBus in) const {
            const TBus select = (in & 0x30) >> 4;
            switch (select) {
                case 0: return static_cast<bool>(in & (1 << 0));
                case 1: return static_cast<bool>(in & (1 << 1));
                case 2: return static_cast<bool>(in & (1 << 2));
                case 3: return static_cast<bool>(in & (1 << 3));
                default:
                    assert(false);
            }
        }
};

class Mux4Factory {
    private:
#ifndef BUILDING_DOX
        struct Mux4Params: public CaEvalParams {
            Mux4Params() {
                caSize = 3;
                nSteps = 4;
            }
        };
#endif

    public:
        typedef MuxGate<6>                              TGate;
        typedef BindInput<0, 0, 0,
                BindInput<1, 0, 2,
                BindInput<2, 2, 0,
                BindInput<3, 2, 1,
                BindInput<4, 0, 1,
                BindInput<5, 1, 1,
                BindOutput<0, 2, 2>
                > > > > > >                             TBinding;
        typedef Mux4Params                              TParams;

    public:
        static CaEvaluator* create() {
            return PrivateFactory<TGate, TBinding, TParams>::create();
        }

    private:
        CT_ASSERT<TBinding::BOUND_INPUTS == 63>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_INPUT_BINDING_FOR_MUX4___;

        CT_ASSERT<TBinding::BOUND_OUTPUTS == 1>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_OUTPUT_BINDING_FOR_MUX4___;
};

template <int N, int CA_SIZE>
struct MulBinder {
    /* no tag - this will fail intentionally */
};

template <> struct MulBinder<5, 3> DOX_FAKE_PARENT(MulBinder)
{
    typedef BindInput<0, 0, 2,
            BindInput<1, 0, 1,
            BindInput<2, 2, 2,
            BindInput<3, 2, 1,
            BindInput<4, 2, 0,
            BindOutput<0, 0, 2,
            BindOutput<1, 2, 2,
            BindOutput<2, 0, 1,
            BindOutput<3, 2, 1,
            BindOutput<4, 2, 0>
            > > > > > > > > > tag;
};

template <> struct MulBinder<6, 3> DOX_FAKE_PARENT(MulBinder)
{
    typedef BindInput<0, 1, 2,
            BindInput<1, 0, 1,
            BindInput<2, 2, 0,
            BindInput<3, 2, 2,
            BindInput<4, 1, 1,
            BindInput<5, 0, 0,
            BindOutput<0, 1, 2,
            BindOutput<1, 0, 2,
            BindOutput<2, 0, 1,
            BindOutput<3, 2, 1,
            BindOutput<4, 2, 0,
            BindOutput<5, 1, 0>
            > > > > > > > > > > > tag;
};

template <> struct MulBinder<6, 4> DOX_FAKE_PARENT(MulBinder)
{
    typedef BindInput<0, 2, 3,
            BindInput<1, 1, 2,
            BindInput<2, 0, 1,
            BindInput<3, 3, 2,
            BindInput<4, 2, 1,
            BindInput<5, 1, 0,
            BindOutput<0, 2, 3,
            BindOutput<1, 3, 2,
            BindOutput<2, 1, 2,
            BindOutput<3, 2, 1,
            BindOutput<4, 0, 1,
            BindOutput<5, 1, 0>
            > > > > > > > > > > > tag;
};

template <int N, int CA_SIZE>
class MulFactory {
    private:
        static const size_t MASK = (1 << N) - 1;
#ifndef BUILDING_DOX
        struct MulParams: public CaEvalParams {
            MulParams() {
                caSize = CA_SIZE;
                nSteps = 13;
            }
        };
#endif

    public:
        typedef MulGate<N>                              TGate;
        typedef typename MulBinder<N, CA_SIZE>::tag     TBinding;
        typedef MulParams                               TParams;

    public:
        static CaEvaluator* create() {
            return PrivateFactory<TGate, TBinding, TParams>::create();
        }

    private:
        CT_ASSERT<TBinding::BOUND_INPUTS == MASK>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_INPUT_BINDING_FOR_MUX4___;

        CT_ASSERT<TBinding::BOUND_OUTPUTS == MASK>
            ___COMPILE_TIME_ERROR__INAPPROPRIATE_OUTPUT_BINDING_FOR_MUX4___;
};

// /////////////////////////////////////////////////////////////////////////////
// CaEvaluatorFactory implementation
#ifndef BUILDING_DOX
struct CaEvaluatorFactory::Private {
    typedef std::map<std::string, CaEvaluator* (*)()>   TMap;
    typedef std::set<std::string>                       TSet;

    TMap map;
    TSet trivialSet;
    TSet complexSet;
};
#endif

CaEvaluatorFactory::CaEvaluatorFactory():
    d(new Private)
{
    // 2-inputs gates
    d->map["and2"] = GateFactory <AndGate, 2> ::create;
    d->map[ "or2"] = GateFactory < OrGate, 2> ::create;
    d->map["xor2"] = GateFactory <XorGate, 2> ::create;

    // 3-inputs gates
    d->map["mux2"] = GateFactory <MuxGate, 3> ::create;
    d->map["and3"] = GateFactory <AndGate, 3> ::create;
    d->map[ "or3"] = GateFactory < OrGate, 3> ::create;
    d->map["xor3"] = GateFactory <XorGate, 3> ::create;

    // 5-inputs gates
    d->map["and5"] = GateFactory <AndGate, 5> ::create;
    d->map[ "or5"] = GateFactory < OrGate, 5> ::create;

    // xor5 converges immediately with incremental nStep
    // TODO: implement incremental nStep as an option
    d->map["xor5"] = GateFactory <XorGate, 5> ::create;

    // wire crossing
    d->map["cross2"] = WireCrossFactory <2> ::create;
    d->map["cross3"] = WireCrossFactory <3> ::create;
    d->map["cross2x2"] = WireCrossFactory <4, BusGate> ::create;

    // 4-input mux converges immediately with incremental caStep
    // TODO: implement incremental nStep as an option
    d->map["mux4"] = Mux4Factory::create;

    // mul
    d->map["mul2x3"] = MulFactory<5, 3>::create;
    d->map["mul3x3-ca3x3"] = MulFactory<6, 3>::create;
    d->map["mul3x3-ca4x4"] = MulFactory<6, 4>::create;

    // mark 2-inputs gates as trivial
    d->trivialSet.insert("and2");
    d->trivialSet.insert( "or2");
    d->trivialSet.insert("xor2");
    d->trivialSet.insert("cross2");

    // mark 4+ inputs gates as complex
    d->complexSet.insert("cross2x2");
    d->complexSet.insert("mux4");
    d->complexSet.insert("and5");
    d->complexSet.insert( "or5");
    d->complexSet.insert("xor5");
    d->complexSet.insert("mul2x3");
    d->complexSet.insert("mul3x3-ca3x3");
    d->complexSet.insert("mul3x3-ca4x4");
}

CaEvaluatorFactory::~CaEvaluatorFactory() {
    delete d;
}

CaEvaluator* CaEvaluatorFactory::create(const std::string &what) {
    // circuit lookup
    Private::TMap::iterator i = d->map.find(what);
    if (i != d->map.end())
        return (i->second)();

    // circuit not found
    // throw an exception containing list of available circuits
    std::ostringstream str;
    str << "invalid circuit: "
        << Color(C_LIGHT_RED) << what << Color(C_NO_COLOR)
        << " (implemented circuits are: " << Color(C_LIGHT_BLUE);
    for (i = d->map.begin(); i != d->map.end(); ++i) {
        if (i != d->map.begin())
            str << ", ";
        str << i->first;
    }
    str << Color(C_NO_COLOR) << ")";
    throw std::runtime_error(str.str());
}

void CaEvaluatorFactory::printList(std::ostream &str) {
    Private::TMap::iterator i;
    for (i = d->map.begin(); i != d->map.end(); ++i) {
#if !GF_INCLUDE_TRIVIAL
        if (d->trivialSet.end() != d->trivialSet.find(i->first))
            continue;
#endif
#if !GF_INCLUDE_COMPLEX
        if (d->complexSet.end() != d->complexSet.find(i->first))
            continue;
#endif
        str << i->first << std::endl;
    }
}

---