AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-10-18 11:10:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move comp code into comp namespace

Browse Source 
This CL moves the code in the comp/ directories into the comp namespace.
This commit is contained in:
dan sinclair 2018-07-06 07:32:39 -04:00 committed by David Neto
parent 5e0276bdc9
commit 9836b05acd
10 changed files with 62 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
source/comp/markv.h
View File

@ -24,10 +24,11 @@
#include <string>
#include <vector>
#include "markv_model.h"
#include "comp/markv_model.h"
#include "spirv-tools/libspirv.hpp"
namespace spvtools {
namespace comp {
struct MarkvCodecOptions {
bool validate_spirv_binary = false;
@ -69,6 +70,7 @@ spv_result_t MarkvToSpirv(
MessageConsumer message_consumer, MarkvLogConsumer log_consumer,
MarkvDebugConsumer debug_consumer, std::vector<uint32_t>* spirv);
} // namespace comp
} // namespace spvtools
#endif // SPIRV_TOOLS_MARKV_HPP_

3
source/comp/markv_codec.cpp
View File

@ -71,7 +71,7 @@ using MoveToFront = spvutils::MoveToFront<uint32_t>;
using MultiMoveToFront = spvutils::MultiMoveToFront<uint32_t>;
namespace spvtools {
namespace comp {
namespace {
const uint32_t kSpirvMagicNumber = SpvMagicNumber;
@ -2898,4 +2898,5 @@ spv_result_t MarkvToSpirv(
return SPV_SUCCESS;
}
} // namespace comp
} // namespace spvtools

2
source/comp/markv_model.h
View File

@ -24,6 +24,7 @@
#include "util/huffman_codec.h"
namespace spvtools {
namespace comp {
// Base class for MARK-V models.
// The class contains encoding/decoding model with various constants and
@ -227,6 +228,7 @@ class MarkvModel {
uint32_t model_version_ = 0;
};
} // namespace comp
} // namespace spvtools
#endif // LIBSPIRV_COMP_MARKV_MODEL_H_

31
test/comp/markv_codec_test.cpp
View File

@ -24,11 +24,12 @@
#include "tools/comp/markv_model_factory.h"
#include "unit_spirv.h"
namespace spvtools {
namespace comp {
namespace {
using libspirv::SetContextMessageConsumer;
using spvtest::ScopedContext;
using spvtools::MarkvModelType;
using MarkvTest = ::testing::TestWithParam<MarkvModelType>;
void DiagnosticsMessageHandler(spv_message_level_t level, const char*,
@ -90,9 +91,8 @@ void Disassemble(const std::vector<uint32_t>& words, std::string* out_text,
void TestEncodeDecode(MarkvModelType model_type,
const std::string& original_text) {
ScopedContext ctx(SPV_ENV_UNIVERSAL_1_2);
std::unique_ptr<spvtools::MarkvModel> model =
spvtools::CreateMarkvModel(model_type);
spvtools::MarkvCodecOptions options;
std::unique_ptr<MarkvModel> model = CreateMarkvModel(model_type);
MarkvCodecOptions options;
std::vector<uint32_t> expected_binary;
Compile(original_text, &expected_binary);
@ -112,18 +112,17 @@ void TestEncodeDecode(MarkvModelType model_type,
[&encoder_comments](const std::string& str) { encoder_comments << str; };
std::vector<uint8_t> markv;
ASSERT_EQ(SPV_SUCCESS, spvtools::SpirvToMarkv(
ctx.context, binary_to_encode, options, *model,
DiagnosticsMessageHandler, output_to_string_stream,
spvtools::MarkvDebugConsumer(), &markv));
ASSERT_EQ(SPV_SUCCESS,
SpirvToMarkv(ctx.context, binary_to_encode, options, *model,
DiagnosticsMessageHandler, output_to_string_stream,
MarkvDebugConsumer(), &markv));
ASSERT_FALSE(markv.empty());
std::vector<uint32_t> decoded_binary;
ASSERT_EQ(SPV_SUCCESS,
spvtools::MarkvToSpirv(
ctx.context, markv, options, *model, DiagnosticsMessageHandler,
spvtools::MarkvLogConsumer(), spvtools::MarkvDebugConsumer(),
&decoded_binary));
MarkvToSpirv(ctx.context, markv, options, *model,
DiagnosticsMessageHandler, MarkvLogConsumer(),
MarkvDebugConsumer(), &decoded_binary));
ASSERT_FALSE(decoded_binary.empty());
EXPECT_EQ(expected_binary, decoded_binary) << encoder_comments.str();
@ -820,9 +819,11 @@ OpFunctionEnd
INSTANTIATE_TEST_CASE_P(AllMarkvModels, MarkvTest,
::testing::ValuesIn(std::vector<MarkvModelType>{
spvtools::kMarkvModelShaderLite,
spvtools::kMarkvModelShaderMid,
spvtools::kMarkvModelShaderMax,
kMarkvModelShaderLite,
kMarkvModelShaderMid,
kMarkvModelShaderMax,
}), );
} // namespace
} // namespace comp
} // namespace spvtools

59
tools/comp/markv.cpp
View File

@ -138,7 +138,8 @@ int main(int argc, char** argv) {
bool want_comments = false;
bool validate_spirv_binary = false;
spvtools::MarkvModelType model_type = spvtools::kMarkvModelUnknown;
spvtools::comp::MarkvModelType model_type =
spvtools::comp::kMarkvModelUnknown;
for (int argi = 2; argi < argc; ++argi) {
if ('-' == argv[argi][0]) {
@ -167,17 +168,17 @@ int main(int argc, char** argv) {
} else if (0 == strcmp(argv[argi], "--validate")) {
validate_spirv_binary = true;
} else if (0 == strcmp(argv[argi], "--model=shader_lite")) {
if (model_type != spvtools::kMarkvModelUnknown)
if (model_type != spvtools::comp::kMarkvModelUnknown)
fprintf(stderr, "error: More than one model specified\n");
model_type = spvtools::kMarkvModelShaderLite;
model_type = spvtools::comp::kMarkvModelShaderLite;
} else if (0 == strcmp(argv[argi], "--model=shader_mid")) {
if (model_type != spvtools::kMarkvModelUnknown)
if (model_type != spvtools::comp::kMarkvModelUnknown)
fprintf(stderr, "error: More than one model specified\n");
model_type = spvtools::kMarkvModelShaderMid;
model_type = spvtools::comp::kMarkvModelShaderMid;
} else if (0 == strcmp(argv[argi], "--model=shader_max")) {
if (model_type != spvtools::kMarkvModelUnknown)
if (model_type != spvtools::comp::kMarkvModelUnknown)
fprintf(stderr, "error: More than one model specified\n");
model_type = spvtools::kMarkvModelShaderMax;
model_type = spvtools::comp::kMarkvModelShaderMax;
} else {
print_usage(argv[0]);
return 1;
@ -206,34 +207,34 @@ int main(int argc, char** argv) {
}
}
if (model_type == spvtools::kMarkvModelUnknown)
model_type = spvtools::kMarkvModelShaderLite;
if (model_type == spvtools::comp::kMarkvModelUnknown)
model_type = spvtools::comp::kMarkvModelShaderLite;
const auto no_comments = spvtools::MarkvLogConsumer();
const auto no_comments = spvtools::comp::MarkvLogConsumer();
const auto output_to_stderr = [](const std::string& str) {
std::cerr << str;
};
ScopedContext ctx(kSpvEnv);
std::unique_ptr<spvtools::MarkvModel> model =
spvtools::CreateMarkvModel(model_type);
std::unique_ptr<spvtools::comp::MarkvModel> model =
spvtools::comp::CreateMarkvModel(model_type);
std::vector<uint32_t> spirv;
std::vector<uint8_t> markv;
spvtools::MarkvCodecOptions options;
spvtools::comp::MarkvCodecOptions options;
options.validate_spirv_binary = validate_spirv_binary;
if (task == kEncode) {
if (!ReadFile<uint32_t>(input_filename, "rb", &spirv)) return 1;
assert(!spirv.empty());
if (SPV_SUCCESS !=
spvtools::SpirvToMarkv(ctx.context, spirv, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
spvtools::MarkvDebugConsumer(), &markv)) {
if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
ctx.context, spirv, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
spvtools::comp::MarkvDebugConsumer(), &markv)) {
std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
<< std::endl;
return 1;
@ -245,11 +246,11 @@ int main(int argc, char** argv) {
if (!ReadFile<uint8_t>(input_filename, "rb", &markv)) return 1;
assert(!markv.empty());
if (SPV_SUCCESS !=
spvtools::MarkvToSpirv(ctx.context, markv, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
spvtools::MarkvDebugConsumer(), &spirv)) {
if (SPV_SUCCESS != spvtools::comp::MarkvToSpirv(
ctx.context, markv, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
spvtools::comp::MarkvDebugConsumer(), &spirv)) {
std::cerr << "error: Failed to decode " << input_filename << " to SPIR-V "
<< std::endl;
return 1;
@ -285,11 +286,11 @@ int main(int argc, char** argv) {
return true;
};
if (SPV_SUCCESS !=
spvtools::SpirvToMarkv(ctx.context, spirv_before, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
encoder_debug_consumer, &markv)) {
if (SPV_SUCCESS != spvtools::comp::SpirvToMarkv(
ctx.context, spirv_before, options, *model,
DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments,
encoder_debug_consumer, &markv)) {
std::cerr << "error: Failed to encode " << input_filename << " to MARK-V "
<< std::endl;
return 1;
@ -355,7 +356,7 @@ int main(int argc, char** argv) {
};
std::vector<uint32_t> spirv_after;
const spv_result_t decoding_result = spvtools::MarkvToSpirv(
const spv_result_t decoding_result = spvtools::comp::MarkvToSpirv(
ctx.context, markv, options, *model, DiagnosticsMessageHandler,
want_comments ? output_to_stderr : no_comments, decoder_debug_consumer,
&spirv_after);

2
tools/comp/markv_model_factory.cpp
View File

@ -17,6 +17,7 @@
#include "markv_model_shader.h"
namespace spvtools {
namespace comp {
std::unique_ptr<MarkvModel> CreateMarkvModel(MarkvModelType type) {
std::unique_ptr<MarkvModel> model;
@ -44,4 +45,5 @@ std::unique_ptr<MarkvModel> CreateMarkvModel(MarkvModelType type) {
return model;
}
} // namespace comp
} // namespace spvtools

2
tools/comp/markv_model_factory.h
View File

@ -20,6 +20,7 @@
#include "source/comp/markv_model.h"
namespace spvtools {
namespace comp {
enum MarkvModelType {
kMarkvModelUnknown = 0,
@ -30,6 +31,7 @@ enum MarkvModelType {
std::unique_ptr<MarkvModel> CreateMarkvModel(MarkvModelType type);
} // namespace comp
} // namespace spvtools
#endif // SPIRV_TOOLS_COMP_MARKV_MODEL_FACTORY_H_

3
tools/comp/markv_model_shader.cpp
View File

@ -24,7 +24,7 @@
using spvutils::HuffmanCodec;
namespace spvtools {
namespace comp {
namespace {
// Signals that the value is not in the coding scheme and a fallback method
@ -97,4 +97,5 @@ MarkvModelShaderMax::MarkvModelShaderMax() {
id_fallback_strategy_ = IdFallbackStrategy::kRuleBased;
}
} // namespace comp
} // namespace spvtools

2
tools/comp/markv_model_shader.h
View File

@ -18,6 +18,7 @@
#include "source/comp/markv_model.h"
namespace spvtools {
namespace comp {
// MARK-V shader compression model, which only uses fast and lightweight
// algorithms, which do not require training and are not heavily dependent on
@ -40,6 +41,7 @@ class MarkvModelShaderMax : public MarkvModel {
MarkvModelShaderMax();
};
} // namespace comp
} // namespace spvtools
#endif // SPIRV_TOOLS_MARKV_MODEL_SHADER_H_

2
tools/stats/stats_analyzer.cpp
View File

@ -39,7 +39,7 @@ namespace {
// Signals that the value is not in the coding scheme and a fallback method
// needs to be used.
const uint64_t kMarkvNoneOfTheAbove =
spvtools::MarkvModel::GetMarkvNoneOfTheAbove();
spvtools::comp::MarkvModel::GetMarkvNoneOfTheAbove();
inline uint32_t CombineOpcodeAndNumOperands(uint32_t opcode,
uint32_t num_operands) {