control.h

Go to the documentation of this file.

/***************************************************************************
*   Copyright 2012 - 2013 Advanced Micro Devices, Inc.
*
*   Licensed under the Apache License, Version 2.0 (the "License");
*   you may not use this file except in compliance with the License.
*   You may obtain a copy of the License at
*
*       http://www.apache.org/licenses/LICENSE-2.0
*
*   Unless required by applicable law or agreed to in writing, software
*   distributed under the License is distributed on an "AS IS" BASIS,
*   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*   See the License for the specific language governing permissions and
*   limitations under the License.

***************************************************************************/


#if !defined( BOLT_AMP_CONTROL_H )
#define BOLT_AMP_CONTROL_H

#pragma once

#include <amp.h>
#include <string>
#include <map>

namespace bolt
{
namespace amp
{

class control {
public:
    enum e_UseHostMode {
        NoUseHost,
        UseHost};
    enum e_RunMode {
        Automatic,
        SerialCpu,
        MultiCoreCpu,
        Gpu };

    enum e_AutoTuneMode{NoAutoTune=0x0,
                        AutoTuneDevice=0x1,
                        AutoTuneWorkShape=0x2,
                        AutoTuneAll=0x3}; // FIXME, experimental
    struct debug {
        static const unsigned None=0;
        static const unsigned Compile = 0x1;
        static const unsigned ShowCode = 0x2;
        static const unsigned SaveCompilerTemps = 0x4;
        static const unsigned DebugKernelRun = 0x8;
        static const unsigned AutoTune = 0x10;
    };

    enum e_WaitMode {
        BalancedWait,   // Balance of Busy and Nice: tries to use Busy for short-running kernels.  \todo: Balanced currently maps to nice.
        NiceWait,       // Use an OS semaphore to detect completion status.
        BusyWait,       // Busy a CPU core continuously monitoring results.  Lowest-latency, but requires a dedicated core.
        ClFinish,      // Call clFinish on the queue.
    };

public:

    // Construct a new control structure, copying from default control for arguments that are not overridden.
    control(
        Concurrency::accelerator accel=getDefault().getAccelerator(),
        e_UseHostMode useHost=getDefault().getUseHost(),
        unsigned debug=getDefault().getDebug()
        ):
        m_accelerator(accel),
        m_useHost(useHost),
        m_forceRunMode(getDefault().m_forceRunMode),
        m_debug(debug),
        m_autoTune(getDefault().m_autoTune),
        m_wgPerComputeUnit(getDefault().m_wgPerComputeUnit),
        m_waitMode(getDefault().m_waitMode),
        m_unroll(getDefault().m_unroll)
    {};

    control( const control& ref) :
        m_accelerator(ref.m_accelerator),
        m_useHost(ref.m_useHost),
        m_forceRunMode(ref.m_forceRunMode),
        m_debug(ref.m_debug),
        m_autoTune(ref.m_autoTune),
        m_wgPerComputeUnit(ref.m_wgPerComputeUnit),
        m_waitMode(ref.m_waitMode),
        m_unroll(ref.m_unroll)
    {
        //printf("control::copy construcor\n");
    };

    //setters:
    void setAccelerator(::Concurrency::accelerator accel) { m_accelerator = accel; };

    void setUseHost(e_UseHostMode useHost) { m_useHost = useHost; };

    void setForceRunMode(e_RunMode forceRunMode) { m_forceRunMode = forceRunMode; };

    void setDebug(unsigned debug) { m_debug = debug; };

    void setWGPerComputeUnit(int wgPerComputeUnit) { m_wgPerComputeUnit = wgPerComputeUnit; };

    void setWaitMode(e_WaitMode waitMode) { m_waitMode = waitMode; };

    void setUnroll(int unroll) { m_unroll = unroll; };

    // getters:
    Concurrency::accelerator& getAccelerator( ) { return m_accelerator; };
    const Concurrency::accelerator& getAccelerator( ) const { return m_accelerator; };

    e_UseHostMode getUseHost() const { return m_useHost; };
    e_RunMode getForceRunMode() const { return m_forceRunMode; };
    unsigned getDebug() const { return m_debug;};
    int const getWGPerComputeUnit() const { return m_wgPerComputeUnit; };
    e_WaitMode getWaitMode() const { return m_waitMode; };
    int getUnroll() const { return m_unroll; };

    static control &getDefault()
    {
        // Default control structure; this can be accessed by the bolt::cl::control::getDefault()
        static control _defaultControl( true );
        return _defaultControl;
    };

    //TODO - implement the below function in control.cpp
    /*static void printPlatforms( bool printDevices = true, cl_device_type deviceType = CL_DEVICE_TYPE_ALL );
    static void printPlatformsRange( std::vector< ::cl::Platform >::iterator begin, std::vector< ::cl::Platform >::iterator end,
                                    bool printDevices = true, cl_device_type deviceType = CL_DEVICE_TYPE_ALL );*/

private:

    // This is the private constructor is only used to create the initial default control structure.
    control(bool createGlobal) :
        m_accelerator( Concurrency::accelerator::default_accelerator ),
        m_useHost(UseHost),
        m_forceRunMode(Automatic),
        m_debug(debug::None),
        m_autoTune(AutoTuneAll),
        m_wgPerComputeUnit(8),
        m_waitMode(BusyWait),
        m_unroll(1)
    {};

    //::cl::CommandQueue  m_commandQueue;
    ::Concurrency::accelerator m_accelerator;
    e_UseHostMode       m_useHost;
    e_RunMode           m_forceRunMode;
    e_AutoTuneMode      m_autoTune;  /* auto-tune the choice of device CPU/GPU and  workgroup shape */
    unsigned            m_debug;
    int                 m_wgPerComputeUnit;
    e_WaitMode          m_waitMode;
    int                 m_unroll;
};
};
};

// Implementor note:
// When adding a new field to this structure, don't forget to:
//   * Add the new field, ie "int _foo.
//   * Add setter function and getter function, ie "void foo(int fooValue)" and "int foo const { return _foo; }"
//   * Add the field to the private constructor.  This is used to set the global default "_defaultControl".
//   * Add the field to the public constructor, copying from the _defaultControl.

// Sample usage:
// Concurrency::accelerator::default_accelerator
// bolt::amp::control ctl(Concurrency::accelerator::default_accelerator);
// c.debug(bolt::amp::control::ShowCompile);
// bolt::amp::reduce(ctl, a.begin(), a.end(), std::plus<int>);


#endif