opencl_program.cpp

Go to the documentation of this file.

/**
    \file
    \brief Contains OpenCL::Program methods.
*/




#include "settings.h"




#if ( SETTING_OPENCL != 0 )




#include "opencl_program.h"
#include "exception.h"
#include "opencl_exception.h"
#include "helpers.h"

#include <boost/iostreams/device/mapped_file.hpp>

#include <vector>
#include <string>
#include <fstream>




namespace OpenCL {




/*==============================================================================
    Program methods
==============================================================================*/


Program::Program(
    std::shared_ptr< State > const& pState,
    char const* const* const filenames,
    char const* const options,
    char const* const logFilename
) :
    m_pState( pState )
{
    cl_int result = CL_SUCCESS;
    cl_device_id const deviceID = m_pState->DeviceID();

    // mmap the source code files
    std::vector< boost::iostreams::mapped_file_source > fileMaps;
    std::vector< boost::iostreams::mapped_file_source::size_type > fileLengths;
    std::vector< char const* > fileContents;
    for ( unsigned int ii = 0; filenames[ ii ] != NULL; ++ii ) {

        fileMaps.push_back( boost::iostreams::mapped_file_source( filenames[ ii ] ) );
        if ( ! fileMaps.back().is_open() )
            THROW_EXCEPTION( "boost::iostreams::mapped_file_source constructor failed!" );
        fileLengths.push_back( fileMaps.back().size() );
        fileContents.push_back( fileMaps.back().data() );
    }
    assert( fileMaps.size() == fileLengths.size()  );
    assert( fileMaps.size() == fileContents.size() );

    // make a cl_program from the source
    m_program.reset( clCreateProgramWithSource( m_pState->Context(), fileMaps.size(), fileContents.data(), fileLengths.data(), &result ) );
    if ( result != CL_SUCCESS )
        THROW_OPENCL_EXCEPTION( "clCreateProgramWithSource failed!", result );

    // try to compile the program
    result = clBuildProgram( m_program.get(), 1, &deviceID, options, NULL, NULL );
    if ( logFilename != NULL ) {

        cl_build_status status = CL_BUILD_NONE;
        cl_int const statusResult = clGetProgramBuildInfo( m_program.get(), deviceID, CL_PROGRAM_BUILD_STATUS, sizeof( status ), &status, NULL );

        size_t optionsLength = 0;
        std::unique_ptr< char[] > options;
        cl_int optionsResult = clGetProgramBuildInfo( m_program.get(), deviceID, CL_PROGRAM_BUILD_OPTIONS, 0, NULL, &optionsLength );
        if ( ( optionsResult == CL_SUCCESS ) && ( optionsLength > 1 ) ) {

            options.reset( new char[ optionsLength ] );
            optionsResult = clGetProgramBuildInfo( m_program.get(), deviceID, CL_PROGRAM_BUILD_OPTIONS, optionsLength, options.get(), &optionsLength );
            if ( ( optionsResult == CL_SUCCESS ) && ( optionsLength > 1 ) ) {

                bool printable = false;
                for ( unsigned int ii = 0; ( ! printable ) && ( ii < optionsLength ); ++ii )
                    printable |= ( std::isprint( options[ ii ] ) != 0 );
                if ( ! printable ) {

                    options[ 0 ] = '\0';
                    optionsLength = 1;
                }
            }
        }

        size_t logLength = 0;
        std::unique_ptr< char[] > log;
        cl_int logResult = clGetProgramBuildInfo( m_program.get(), deviceID, CL_PROGRAM_BUILD_LOG, 0, NULL, &logLength );
        if ( ( logResult == CL_SUCCESS ) && ( logLength > 1 ) ) {

            log.reset( new char[ logLength ] );
            logResult = clGetProgramBuildInfo( m_program.get(), deviceID, CL_PROGRAM_BUILD_LOG, logLength, log.get(), &logLength );
            if ( ( logResult == CL_SUCCESS ) && ( logLength > 1 ) ) {

                bool printable = false;
                for ( unsigned int ii = 0; ( ! printable ) && ( ii < logLength ); ++ii )
                    printable |= ( std::isprint( log[ ii ] ) != 0 );
                if ( ! printable ) {

                    log[ 0 ] = '\0';
                    logLength = 1;
                }
            }
        }

        if ( ( ( statusResult == CL_SUCCESS ) && ( status != CL_BUILD_SUCCESS ) ) || ( ( logResult == CL_SUCCESS ) && ( logLength > 1 ) ) ) {

            std::ofstream logFile( logFilename, std::ios_base::out | std::ios_base::trunc );
            if ( ! logFile.is_open() )
                THROW_EXCEPTION( "std::ofstream constructor failed!" );

            bool printed = false;
            if ( statusResult == CL_SUCCESS ) {

                char const* message = "<unknown status>";
                switch( status ) {
                    case CL_BUILD_NONE:        { message = "CL_BUILD_NONE";        break; }
                    case CL_BUILD_ERROR:       { message = "CL_BUILD_ERROR";       break; }
                    case CL_BUILD_SUCCESS:     { message = "CL_BUILD_SUCCESS";     break; }
                    case CL_BUILD_IN_PROGRESS: { message = "CL_BUILD_IN_PROGRESS"; break; }
                }
                logFile << "Build status = " << message << " (code=" << status << ')' << std::endl;
                printed = true;
            }
            if ( ( optionsResult == CL_SUCCESS ) && ( optionsLength > 1 ) ) {

                logFile << "Build options = \"" << CollapseWhitespace( options.get() ) << '"' << std::endl;
                printed = true;
            }
            if ( ( logResult == CL_SUCCESS ) && ( logLength > 1 ) ) {

                if ( printed )
                    logFile << std::endl << std::endl;

                logFile <<
                    "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << std::endl <<
                    "    Build log" << std::endl <<
                    "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << std::endl <<
                    std::endl;

                // strip whitespace
                int ii = 0;
                int iiEnd = logLength - 1;
                for ( ; ( ii < iiEnd ) && ( ! std::isprint( log[ ii    ] ) ); ++ii );
                for ( ; ( iiEnd > ii ) && ( ! std::isprint( log[ iiEnd ] ) ); --iiEnd );
                logFile.write( log.get() + ii, 1 + iiEnd - ii );

                logFile << std::endl;
                printed = true;
            }
            for ( unsigned int ii = 0; ii < fileMaps.size(); ++ii ) {

                if ( printed )
                    logFile << std::endl << std::endl;

                logFile <<
                    "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << std::endl <<
                    "    Source code - \"" << filenames[ ii ] << '"' << std::endl <<
                    "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-" << std::endl <<
                    std::endl;

                // strip whitespace
                int jj = 0;
                int jjEnd = fileLengths[ ii ];
                for ( ; ( jj < jjEnd ) && ( ! std::isprint( fileContents[ ii ][ jj    ] ) ); ++jj );
                for ( ; ( jjEnd > jj ) && ( ! std::isprint( fileContents[ ii ][ jjEnd ] ) ); --jjEnd );
                logFile.write( fileContents[ ii ] + jj, 1 + jjEnd - jj );

                logFile << std::endl;
                printed = true;
            }
        }
    }
    if ( result != CL_SUCCESS )
        THROW_OPENCL_EXCEPTION( "clBuildProgram failed!", result );
}




}    // namespace OpenCL




#endif    // SETTING_OPENCL