mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-20 12:05:48 -04:00
b459eb3529
Summary: Before, the kernel spec would only return PTX for exactly the requested compute capability. With this patch it will now return the PTX with the largest compute capability that does not exceed that requested compute capability. Reviewers: jlebar Subscribers: jprice, jlebar, parallel_libs-commits Differential Revision: https://reviews.llvm.org/D24531 llvm-svn: 281417
136 lines
5.0 KiB
C++
136 lines
5.0 KiB
C++
//===-- KernelSpecTest.cpp - Tests for KernelSpec -------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// This file contains the unit tests for the code in KernelSpec.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "streamexecutor/KernelSpec.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
namespace {
|
|
|
|
namespace se = ::streamexecutor;
|
|
|
|
TEST(CUDAPTXInMemorySpec, NoCode) {
|
|
se::CUDAPTXInMemorySpec Spec("KernelName", {});
|
|
EXPECT_EQ("KernelName", Spec.getKernelName());
|
|
EXPECT_EQ(nullptr, Spec.getCode(1, 0));
|
|
}
|
|
|
|
TEST(CUDAPTXInMemorySpec, SingleComputeCapability) {
|
|
const char *PTXCodeString = "Dummy PTX code";
|
|
se::CUDAPTXInMemorySpec Spec("KernelName", {{{1, 0}, PTXCodeString}});
|
|
EXPECT_EQ("KernelName", Spec.getKernelName());
|
|
EXPECT_EQ(nullptr, Spec.getCode(0, 5));
|
|
EXPECT_EQ(PTXCodeString, Spec.getCode(1, 0));
|
|
EXPECT_EQ(PTXCodeString, Spec.getCode(2, 0));
|
|
}
|
|
|
|
TEST(CUDAPTXInMemorySpec, TwoComputeCapabilities) {
|
|
const char *PTXCodeString10 = "Dummy PTX code 10";
|
|
const char *PTXCodeString30 = "Dummy PTX code 30";
|
|
se::CUDAPTXInMemorySpec Spec(
|
|
"KernelName", {{{1, 0}, PTXCodeString10}, {{3, 0}, PTXCodeString30}});
|
|
EXPECT_EQ("KernelName", Spec.getKernelName());
|
|
EXPECT_EQ(nullptr, Spec.getCode(0, 5));
|
|
EXPECT_EQ(PTXCodeString10, Spec.getCode(1, 0));
|
|
EXPECT_EQ(PTXCodeString30, Spec.getCode(3, 0));
|
|
EXPECT_EQ(PTXCodeString10, Spec.getCode(2, 0));
|
|
}
|
|
|
|
TEST(CUDAFatbinInMemorySpec, BasicUsage) {
|
|
const char *FatbinBytes = "Dummy fatbin bytes";
|
|
se::CUDAFatbinInMemorySpec Spec("KernelName", FatbinBytes);
|
|
EXPECT_EQ("KernelName", Spec.getKernelName());
|
|
EXPECT_EQ(FatbinBytes, Spec.getBytes());
|
|
}
|
|
|
|
TEST(OpenCLTextInMemorySpec, BasicUsage) {
|
|
const char *OpenCLText = "Dummy OpenCL text";
|
|
se::OpenCLTextInMemorySpec Spec("KernelName", OpenCLText);
|
|
EXPECT_EQ("KernelName", Spec.getKernelName());
|
|
EXPECT_EQ(OpenCLText, Spec.getText());
|
|
}
|
|
|
|
TEST(MultiKernelLoaderSpec, NoCode) {
|
|
se::MultiKernelLoaderSpec MultiSpec;
|
|
EXPECT_FALSE(MultiSpec.hasCUDAPTXInMemory());
|
|
EXPECT_FALSE(MultiSpec.hasCUDAFatbinInMemory());
|
|
EXPECT_FALSE(MultiSpec.hasOpenCLTextInMemory());
|
|
|
|
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAPTXInMemory(),
|
|
"getting spec that is not present");
|
|
EXPECT_DEBUG_DEATH(MultiSpec.getCUDAFatbinInMemory(),
|
|
"getting spec that is not present");
|
|
EXPECT_DEBUG_DEATH(MultiSpec.getOpenCLTextInMemory(),
|
|
"getting spec that is not present");
|
|
}
|
|
|
|
TEST(MultiKernelLoaderSpec, Registration) {
|
|
se::MultiKernelLoaderSpec MultiSpec;
|
|
const char *KernelName = "KernelName";
|
|
const char *PTXCodeString = "Dummy PTX code";
|
|
const char *FatbinBytes = "Dummy fatbin bytes";
|
|
const char *OpenCLText = "Dummy OpenCL text";
|
|
|
|
MultiSpec.addCUDAPTXInMemory(KernelName, {{{1, 0}, PTXCodeString}})
|
|
.addCUDAFatbinInMemory(KernelName, FatbinBytes)
|
|
.addOpenCLTextInMemory(KernelName, OpenCLText);
|
|
|
|
EXPECT_TRUE(MultiSpec.hasCUDAPTXInMemory());
|
|
EXPECT_TRUE(MultiSpec.hasCUDAFatbinInMemory());
|
|
EXPECT_TRUE(MultiSpec.hasOpenCLTextInMemory());
|
|
|
|
EXPECT_EQ(KernelName, MultiSpec.getCUDAPTXInMemory().getKernelName());
|
|
EXPECT_EQ(nullptr, MultiSpec.getCUDAPTXInMemory().getCode(0, 5));
|
|
EXPECT_EQ(PTXCodeString, MultiSpec.getCUDAPTXInMemory().getCode(1, 0));
|
|
EXPECT_EQ(PTXCodeString, MultiSpec.getCUDAPTXInMemory().getCode(2, 0));
|
|
|
|
EXPECT_EQ(KernelName, MultiSpec.getCUDAFatbinInMemory().getKernelName());
|
|
EXPECT_EQ(FatbinBytes, MultiSpec.getCUDAFatbinInMemory().getBytes());
|
|
|
|
EXPECT_EQ(KernelName, MultiSpec.getOpenCLTextInMemory().getKernelName());
|
|
EXPECT_EQ(OpenCLText, MultiSpec.getOpenCLTextInMemory().getText());
|
|
}
|
|
|
|
TEST(MultiKernelLoaderSpec, RegisterTwice) {
|
|
se::MultiKernelLoaderSpec MultiSpec;
|
|
const char *KernelName = "KernelName";
|
|
const char *FatbinBytes = "Dummy fatbin bytes";
|
|
|
|
MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes);
|
|
|
|
EXPECT_DEBUG_DEATH(MultiSpec.addCUDAFatbinInMemory(KernelName, FatbinBytes),
|
|
"illegal loader spec overwrite");
|
|
}
|
|
|
|
TEST(MultiKernelLoaderSpec, ConflictingKernelNames) {
|
|
se::MultiKernelLoaderSpec MultiSpec;
|
|
const char *KernelNameA = "KernelName";
|
|
std::string KernelNameB = KernelNameA;
|
|
const char *PTXCodeString = "Dummy PTX code";
|
|
const char *FatbinBytes = "Dummy fatbin bytes";
|
|
|
|
// Check that names don't conflict if they are equivalent strings in different
|
|
// locations.
|
|
MultiSpec.addCUDAPTXInMemory(KernelNameA, {{{1, 0}, PTXCodeString}})
|
|
.addCUDAFatbinInMemory(KernelNameB, FatbinBytes);
|
|
|
|
const char *OtherKernelName = "OtherKernelName";
|
|
const char *OpenCLText = "Dummy OpenCL text";
|
|
EXPECT_DEBUG_DEATH(
|
|
MultiSpec.addOpenCLTextInMemory(OtherKernelName, OpenCLText),
|
|
"different kernel names in one MultiKernelLoaderSpec");
|
|
}
|
|
|
|
} // namespace
|