wehub-resource-sync
291 lines
8.8 KiB
C++
291 lines
8.8 KiB
C++
/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
|
|
|
|
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. */
|
|
|
|
#include "paddle/fluid/platform/device/ipu/ipu_utils.h"
|
|
|
|
#include <cmath>
|
|
|
|
namespace paddle {
|
|
namespace platform {
|
|
namespace ipu {
|
|
|
|
const popart::DataType VarType2PopartDType(const VarType::Type type) {
|
|
switch (type) {
|
|
case VarType::UINT8:
|
|
return popart::DataType::UINT8;
|
|
case VarType::INT8:
|
|
return popart::DataType::INT8;
|
|
case VarType::INT16:
|
|
return popart::DataType::INT16;
|
|
case VarType::INT32:
|
|
return popart::DataType::INT32;
|
|
case VarType::INT64:
|
|
return popart::DataType::INT64;
|
|
case VarType::BOOL:
|
|
return popart::DataType::BOOL;
|
|
case VarType::FP64:
|
|
return popart::DataType::DOUBLE;
|
|
case VarType::FP32:
|
|
return popart::DataType::FLOAT;
|
|
case VarType::FP16:
|
|
return popart::DataType::FLOAT16;
|
|
case VarType::BF16:
|
|
return popart::DataType::BFLOAT16;
|
|
case VarType::COMPLEX64:
|
|
return popart::DataType::COMPLEX64;
|
|
case VarType::COMPLEX128:
|
|
return popart::DataType::COMPLEX128;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported VarType::Type when converting to popart data type."));
|
|
}
|
|
}
|
|
|
|
const popart::DataType PhiDType2PopartDType(const phi::DataType type) {
|
|
switch (type) {
|
|
case phi::DataType::UINT8:
|
|
return popart::DataType::UINT8;
|
|
case phi::DataType::INT8:
|
|
return popart::DataType::INT8;
|
|
case phi::DataType::INT16:
|
|
return popart::DataType::INT16;
|
|
case phi::DataType::INT32:
|
|
return popart::DataType::INT32;
|
|
case phi::DataType::INT64:
|
|
return popart::DataType::INT64;
|
|
case phi::DataType::BOOL:
|
|
return popart::DataType::BOOL;
|
|
case phi::DataType::FLOAT64:
|
|
return popart::DataType::DOUBLE;
|
|
case phi::DataType::FLOAT32:
|
|
return popart::DataType::FLOAT;
|
|
case phi::DataType::FLOAT16:
|
|
return popart::DataType::FLOAT16;
|
|
case phi::DataType::BFLOAT16:
|
|
return popart::DataType::BFLOAT16;
|
|
case phi::DataType::COMPLEX64:
|
|
return popart::DataType::COMPLEX64;
|
|
case phi::DataType::COMPLEX128:
|
|
return popart::DataType::COMPLEX128;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported phi::DataType when converting to popart data type."));
|
|
}
|
|
}
|
|
|
|
const phi::DataType PopefDtype2PhiDtype(const popef::DataType type) {
|
|
switch (type) {
|
|
case popef::DataType::U8:
|
|
return phi::DataType::UINT8;
|
|
case popef::DataType::S8:
|
|
return phi::DataType::INT8;
|
|
case popef::DataType::S16:
|
|
return phi::DataType::INT16;
|
|
case popef::DataType::S32:
|
|
return phi::DataType::INT32;
|
|
case popef::DataType::S64:
|
|
return phi::DataType::INT64;
|
|
case popef::DataType::BOOL:
|
|
return phi::DataType::BOOL;
|
|
case popef::DataType::F64:
|
|
return phi::DataType::FLOAT64;
|
|
case popef::DataType::F32:
|
|
return phi::DataType::FLOAT32;
|
|
case popef::DataType::F16:
|
|
return phi::DataType::FLOAT16;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported phi::DataType when converting to popef data type."));
|
|
}
|
|
}
|
|
|
|
const VarType::Type PopartDType2VarType(const popart::DataType type) {
|
|
switch (type) {
|
|
case popart::DataType::UINT8:
|
|
return VarType::UINT8;
|
|
case popart::DataType::INT8:
|
|
return VarType::INT8;
|
|
case popart::DataType::INT16:
|
|
return VarType::INT16;
|
|
case popart::DataType::INT32:
|
|
return VarType::INT32;
|
|
case popart::DataType::INT64:
|
|
return VarType::INT64;
|
|
case popart::DataType::BOOL:
|
|
return VarType::BOOL;
|
|
case popart::DataType::DOUBLE:
|
|
return VarType::FP64;
|
|
case popart::DataType::FLOAT:
|
|
return VarType::FP32;
|
|
case popart::DataType::FLOAT16:
|
|
return VarType::FP16;
|
|
case popart::DataType::BFLOAT16:
|
|
return VarType::BF16;
|
|
case popart::DataType::COMPLEX64:
|
|
return VarType::COMPLEX64;
|
|
case popart::DataType::COMPLEX128:
|
|
return VarType::COMPLEX128;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported popart::DataType when converting to var type."));
|
|
}
|
|
}
|
|
|
|
const VarType::Type PopefDType2VarType(const popef::DataType type) {
|
|
switch (type) {
|
|
case popef::DataType::U8:
|
|
return VarType::UINT8;
|
|
case popef::DataType::S8:
|
|
return VarType::INT8;
|
|
case popef::DataType::S16:
|
|
return VarType::INT16;
|
|
case popef::DataType::S32:
|
|
return VarType::INT32;
|
|
case popef::DataType::S64:
|
|
return VarType::INT64;
|
|
case popef::DataType::BOOL:
|
|
return VarType::BOOL;
|
|
case popef::DataType::F64:
|
|
return VarType::FP64;
|
|
case popef::DataType::F32:
|
|
return VarType::FP32;
|
|
case popef::DataType::F16:
|
|
return VarType::FP16;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported popart::DataType when converting to var type."));
|
|
}
|
|
}
|
|
|
|
const popart::DataType OnnxDType2PopartType(const ONNXDataType type) {
|
|
switch (type) {
|
|
case ONNXDataType::BOOL:
|
|
return popart::DataType::BOOL;
|
|
case ONNXDataType::INT16:
|
|
return popart::DataType::INT16;
|
|
case ONNXDataType::INT32:
|
|
return popart::DataType::INT32;
|
|
case ONNXDataType::INT64:
|
|
return popart::DataType::INT64;
|
|
case ONNXDataType::FLOAT16:
|
|
return popart::DataType::FLOAT16;
|
|
case ONNXDataType::FLOAT:
|
|
return popart::DataType::FLOAT;
|
|
case ONNXDataType::DOUBLE:
|
|
return popart::DataType::DOUBLE;
|
|
case ONNXDataType::UINT8:
|
|
return popart::DataType::UINT8;
|
|
case ONNXDataType::INT8:
|
|
return popart::DataType::INT8;
|
|
case ONNXDataType::BFLOAT16:
|
|
return popart::DataType::BFLOAT16;
|
|
case ONNXDataType::COMPLEX64:
|
|
return popart::DataType::COMPLEX64;
|
|
case ONNXDataType::COMPLEX128:
|
|
return popart::DataType::COMPLEX128;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported ONNXDataType when converting to popart data type."));
|
|
}
|
|
}
|
|
|
|
const ONNXDataType VarType2OnnxDType(const VarType::Type type) {
|
|
switch (type) {
|
|
case VarType::BOOL:
|
|
return ONNXDataType::BOOL;
|
|
case VarType::INT16:
|
|
return ONNXDataType::INT16;
|
|
case VarType::INT32:
|
|
return ONNXDataType::INT32;
|
|
case VarType::INT64:
|
|
return ONNXDataType::INT64;
|
|
case VarType::FP16:
|
|
return ONNXDataType::FLOAT16;
|
|
case VarType::FP32:
|
|
return ONNXDataType::FLOAT;
|
|
case VarType::FP64:
|
|
return ONNXDataType::DOUBLE;
|
|
case VarType::UINT8:
|
|
return ONNXDataType::UINT8;
|
|
case VarType::INT8:
|
|
return ONNXDataType::INT8;
|
|
case VarType::BF16:
|
|
return ONNXDataType::BFLOAT16;
|
|
case VarType::COMPLEX64:
|
|
return ONNXDataType::COMPLEX64;
|
|
case VarType::COMPLEX128:
|
|
return ONNXDataType::COMPLEX128;
|
|
default:
|
|
PADDLE_THROW(common::errors::Unimplemented(
|
|
"Unsupported VarType::Type when converting to onnx data type."));
|
|
}
|
|
}
|
|
|
|
const std::string VarType2PopartStr(const VarType::Type type) {
|
|
switch (type) {
|
|
case VarType::UINT8:
|
|
return "UINT8";
|
|
case VarType::INT8:
|
|
return "INT8";
|
|
case VarType::INT16:
|
|
return "INT16";
|
|
case VarType::INT32:
|
|
return "INT32";
|
|
case VarType::INT64:
|
|
return "INT64";
|
|
case VarType::BOOL:
|
|
return "BOOL";
|
|
case VarType::FP64:
|
|
return "DOUBLE";
|
|
case VarType::FP32:
|
|
return "FLOAT";
|
|
case VarType::FP16:
|
|
return "FLOAT16";
|
|
default:
|
|
PADDLE_THROW(common::errors::Unavailable(
|
|
"Unsupported VarType::Type when converting to popart type string."));
|
|
}
|
|
}
|
|
|
|
const bool GetBoolEnv(const std::string& str) {
|
|
char* str_val = getenv(str.c_str());
|
|
if (str_val == NULL) {
|
|
return false;
|
|
} else {
|
|
bool val = false;
|
|
if (strcmp(str_val, "1") == 0 || strcmp(str_val, "true") == 0 ||
|
|
strcmp(str_val, "True") == 0 || strcmp(str_val, "TRUE") == 0)
|
|
val = true;
|
|
return val;
|
|
}
|
|
}
|
|
|
|
const int RequestIpus(const int num_ipus) {
|
|
return std::pow(2, ceil(log2(num_ipus)));
|
|
}
|
|
|
|
std::shared_ptr<popef::Model> PopartSessionToPopefModel(
|
|
popart::Session* session) {
|
|
VLOG(10) << "Converting popart session to popef model";
|
|
auto temp_stream = std::make_shared<std::stringstream>();
|
|
session->compileAndExport(*temp_stream);
|
|
auto reader = std::make_shared<popef::Reader>();
|
|
reader->parseStream(temp_stream);
|
|
return popef::ModelBuilder(reader).createModel();
|
|
}
|
|
|
|
} // namespace ipu
|
|
} // namespace platform
|
|
} // namespace paddle
|