Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Add custom kernel #119

Merged
merged 7 commits into from Nov 28, 2022
Merged

Add custom kernel #119

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
9a696a9
ADD: Custom kernel class
StRigaud Nov 24, 2022
f169543
FIX: small typo and bug
StRigaud Nov 24, 2022
5a8ef77
FIX: path to kernel source
StRigaud Nov 25, 2022
ecc1f43
ADD: error message if file is not found
StRigaud Nov 28, 2022
d88b3c0
FIX: path to kernel file
StRigaud Nov 28, 2022
18f6a42
FIX: path to kernel file
StRigaud Nov 28, 2022
41c0972
FIX: use ${PROJECT_SOURCE_DIR} for path specification
StRigaud Nov 28, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
39 changes: 39 additions & 0 deletions clic/include/tier1/cleCustomKernel.hpp
View file
Open in desktop
@@ -0,0 +1,39 @@
#ifndef __TIER1_CLECUSTOMKERNEL_HPP
#define __TIER1_CLECUSTOMKERNEL_HPP

#include "cleOperation.hpp"

namespace cle
{

class CustomKernel : public Operation
{
public:
explicit CustomKernel(const ProcessorPointer & device,
const std::string & filename,
const std::string & name,
const size_t & nb_parameters);

auto
AddImages(const std::map<std::string, Image> & images) -> void;

auto
AddScalars(const std::map<std::string, float> & scalars) -> void;
};

inline auto
CustomKernel_Call(const std::shared_ptr<cle::Processor> & device,
const std::string & filename,
const std::string & name,
const std::map<std::string, Image> & images,
const std::map<std::string, float> & scalars) -> void
{
CustomKernel kernel(device, filename, name, images.size() + scalars.size());
kernel.AddImages(images);
kernel.AddScalars(scalars);
kernel.Execute();
}

} // namespace cle

#endif // __TIER1_CLECUSTOMKERNEL_HPP
42 changes: 42 additions & 0 deletions clic/src/tier1/cleCustomKernel.cpp
View file
Open in desktop
@@ -0,0 +1,42 @@
#include "cleCustomKernel.hpp"

#include <fstream>
#include <string>

namespace cle
{

CustomKernel::CustomKernel(const ProcessorPointer & device,
const std::string & filename,
const std::string & name,
const size_t & nb_parameters)
: Operation(device, nb_parameters)
{
std::ifstream ifs(filename);
if (ifs.fail())
{
std::cout << "Error in loading custom kernel, could not find file " << filename << std::endl;
}
std::string ocl_source((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
this->SetSource(name, ocl_source);
}

auto
CustomKernel::AddImages(const std::map<std::string, Image> & images) -> void
{
for (auto ite = images.begin(); ite != images.end(); ite++)
{
this->AddParameter(ite->first, ite->second);
}
}

auto
CustomKernel::AddScalars(const std::map<std::string, float> & scalars) -> void
{
for (auto ite = scalars.begin(); ite != scalars.end(); ite++)
{
this->AddParameter(ite->first, ite->second);
}
}

} // namespace cle
8 changes: 8 additions & 0 deletions tests/CMakeLists.txt
View file
Open in desktop
Expand Up @@ -64,6 +64,12 @@ target_link_libraries(binary_or_test PRIVATE CLIc::CLIc)
set_target_properties(binary_or_test PROPERTIES FOLDER "Tests")
target_compile_features(binary_or_test PRIVATE cxx_std_17)

add_executable(custom_kernel_test custom_kernel_test.cpp)
add_dependencies(custom_kernel_test CLIc)
target_link_libraries(custom_kernel_test PRIVATE CLIc::CLIc)
set_target_properties(custom_kernel_test PROPERTIES FOLDER "Tests")
target_compile_features(custom_kernel_test PRIVATE cxx_std_17)

add_executable(binary_subtract_test binary_subtract_test.cpp)
add_dependencies(binary_subtract_test CLIc)
target_link_libraries(binary_subtract_test PRIVATE CLIc::CLIc)
Expand Down Expand Up @@ -405,6 +411,7 @@ add_test(NAME core_scalar_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COM
add_test(NAME core_buffer_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/core_buffer_test)
add_test(NAME core_image_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/core_image_test)
add_test(NAME core_kernel_test_buffer WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/core_kernel_test buffer)
add_test(NAME custom_kernel_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/custom_kernel_test ${PROJECT_SOURCE_DIR}/thirdparty/clesperanto-kernels/kernels/absolute.cl)
# add_test(NAME core_kernel_test_image WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_CURRENT_BINARY_DIR}/core_kernel_test image)
add_test(NAME absolute_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND absolute_test)
add_test(NAME add_image_and_scalar_test WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMAND add_image_and_scalar_test)
Expand Down Expand Up @@ -534,6 +541,7 @@ set_tests_properties(absolute_test
smaller_or_equal_test
smaller_test
sobel_test
custom_kernel_test
sum_all_pixels_test
sum_reduction_x_test
sum_x_projection_test
Expand Down
155 changes: 155 additions & 0 deletions tests/custom_kernel_test.cpp
View file
Open in desktop
@@ -0,0 +1,155 @@


#include <random>

#include "cleCustomKernel.hpp"
#include "clesperanto.hpp"

template <class type>
auto
run_test(const std::array<size_t, 3> & shape, const cle::MemoryType & mem_type, const std::string & path) -> bool
{
type value = static_cast<type>(rand() % 10);
std::vector<type> input(shape[0] * shape[1] * shape[2]);
std::vector<type> valid(shape[0] * shape[1] * shape[2]);
std::fill(input.begin(), input.end(), -value);
std::fill(valid.begin(), valid.end(), value);

cle::Clesperanto cle;
cle.GetDevice()->WaitForKernelToFinish();

auto gpu_input = cle.Push<type>(input, shape, mem_type);
auto gpu_output = cle.Create<type>(shape, mem_type);

cle::CustomKernel_Call(cle.GetDevice(), path, "absolute", { { "src", gpu_input }, { "dst", gpu_output } }, {});

auto output = cle.Pull<type>(gpu_output);

return std::equal(output.begin(), output.end(), valid.begin());
}

auto
main(int argc, char ** argv) -> int
{
if (!run_test<float>({ 10, 1, 1 }, cle::BUFFER, argv[1]))
{
return EXIT_FAILURE;
}

// if (!run_test<signed int>({ 10, 1, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 1, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 1, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<float>({ 10, 5, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed int>({ 10, 5, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 5, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 5, 1 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<float>({ 10, 5, 3 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed int>({ 10, 5, 3 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 5, 3 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 5, 3 }, cle::BUFFER))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<float>({ 10, 1, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed int>({ 10, 1, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 1, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 1, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<float>({ 10, 5, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed int>({ 10, 5, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 5, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 5, 1 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<float>({ 10, 5, 3 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed int>({ 10, 5, 3 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed short>({ 10, 5, 3 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

// if (!run_test<signed char>({ 10, 5, 3 }, cle::IMAGE))
// {
// return EXIT_FAILURE;
// }

return EXIT_SUCCESS;
}