hexsha
stringlengths 40
40
| size
int64 7
1.05M
| ext
stringclasses 13
values | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 4
269
| max_stars_repo_name
stringlengths 5
109
| max_stars_repo_head_hexsha
stringlengths 40
40
| max_stars_repo_licenses
listlengths 1
9
| max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 4
269
| max_issues_repo_name
stringlengths 5
116
| max_issues_repo_head_hexsha
stringlengths 40
40
| max_issues_repo_licenses
listlengths 1
9
| max_issues_count
int64 1
48.5k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 4
269
| max_forks_repo_name
stringlengths 5
116
| max_forks_repo_head_hexsha
stringlengths 40
40
| max_forks_repo_licenses
listlengths 1
9
| max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | content
stringlengths 7
1.05M
| avg_line_length
float64 1.21
330k
| max_line_length
int64 6
990k
| alphanum_fraction
float64 0.01
0.99
| author_id
stringlengths 2
40
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
78a21db9c35c14e171b161afd36f7550d6438374
| 567
|
hpp
|
C++
|
plugins/community/repos/Bogaudio/src/Switch.hpp
|
x42/VeeSeeVSTRack
|
0f5576f92e026ac1480e1477e55084911eca4052
|
[
"Zlib",
"BSD-3-Clause"
] | null | null | null |
plugins/community/repos/Bogaudio/src/Switch.hpp
|
x42/VeeSeeVSTRack
|
0f5576f92e026ac1480e1477e55084911eca4052
|
[
"Zlib",
"BSD-3-Clause"
] | null | null | null |
plugins/community/repos/Bogaudio/src/Switch.hpp
|
x42/VeeSeeVSTRack
|
0f5576f92e026ac1480e1477e55084911eca4052
|
[
"Zlib",
"BSD-3-Clause"
] | null | null | null |
#pragma once
#include "bogaudio.hpp"
extern Model* modelSwitch;
namespace bogaudio {
struct Switch : Module {
enum ParamsIds {
GATE_PARAM,
NUM_PARAMS
};
enum InputsIds {
GATE_INPUT,
HIGH1_INPUT,
LOW1_INPUT,
HIGH2_INPUT,
LOW2_INPUT,
NUM_INPUTS
};
enum OutputsIds {
OUT1_OUTPUT,
OUT2_OUTPUT,
NUM_OUTPUTS
};
enum LightsIds {
NUM_LIGHTS
};
SchmittTrigger _trigger;
Switch() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {
onReset();
}
void onReset() override;
void step() override;
};
} // namespace bogaudio
| 12.6
| 69
| 0.700176
|
x42
|
78a55d99f8497d34258d2ac649927972bf4c2776
| 441
|
hpp
|
C++
|
src/utils/log.hpp
|
talyian/GB-emulator
|
33edfc990cfeed410915334f707615bd3eabefd9
|
[
"MIT"
] | 1
|
2020-08-06T15:25:01.000Z
|
2020-08-06T15:25:01.000Z
|
src/utils/log.hpp
|
talyian/spgb
|
33edfc990cfeed410915334f707615bd3eabefd9
|
[
"MIT"
] | null | null | null |
src/utils/log.hpp
|
talyian/spgb
|
33edfc990cfeed410915334f707615bd3eabefd9
|
[
"MIT"
] | null | null | null |
#pragma once
#include "../base.hpp"
#include "../gb/lib_gb.hpp"
#include "str.hpp"
namespace logs {
void _log(u8 v);
void _log(u16 v);
void _log(u32 v);
void _log(i32 v);
void _log(double f);
void _log(const char * s);
void _log(str s);
void _log(void* s);
template<class T>
void log(T x) { _log(x); spgb_showlog (); }
template<class T, class ... TS>
void log(T x, TS ... xs) { _log(x); log(xs...); }
}
using logs::log;
using logs::_log;
| 18.375
| 49
| 0.639456
|
talyian
|
78a5e1cd2fca40b30eef31167c42abc8d681b939
| 3,896
|
cpp
|
C++
|
src/http/handler.cpp
|
halivor/php-flame
|
5674bcb11838cfcfdaf4d0211bd3b062945775d3
|
[
"MIT"
] | null | null | null |
src/http/handler.cpp
|
halivor/php-flame
|
5674bcb11838cfcfdaf4d0211bd3b062945775d3
|
[
"MIT"
] | null | null | null |
src/http/handler.cpp
|
halivor/php-flame
|
5674bcb11838cfcfdaf4d0211bd3b062945775d3
|
[
"MIT"
] | null | null | null |
#include "../coroutine.h"
#include "value_body.h"
#include "server_request.h"
#include "server_response.h"
#include "server.h"
#include "handler.h"
#include "http.h"
namespace flame {
namespace http {
handler::handler(server* svr, tcp::socket&& sock, std::shared_ptr<flame::coroutine> co)
: svr_(svr)
, socket_(std::move(sock))
, co_(co) {
}
handler::~handler() {
}
void handler::handle(const boost::system::error_code& error, std::size_t n) { BOOST_ASIO_CORO_REENTER(this) {
do {
// 准备接收请求
req_.reset(new boost::beast::http::message<true, value_body<true>>());
BOOST_ASIO_CORO_YIELD boost::beast::http::async_read(socket_, buffer_, *req_,
std::bind(&handler::handle, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2));
// 服务端逻辑 (暂不报错)
if(error) return;
// 准备拼装响应
res_.reset(new boost::beast::http::message<false, value_body<false>>());
res_->keep_alive(req_->keep_alive());
BOOST_ASIO_CORO_YIELD {
php::object req = php::object(php::class_entry<server_request>::entry());
php::object res = php::object(php::class_entry<server_response>::entry());
server_request* req_ptr = static_cast<server_request*>(php::native(req));
server_response* res_ptr = static_cast<server_response*>(php::native(res));
// 将 C++ 请求对象展开到 PHP 中
req_ptr->build_ex(*req_);
auto ptr = req_ptr->handler_ = res_ptr->handler_ = this->shared_from_this();
// 启动协程执行请求处理流程(before/route/after)
// 注意: 在此流程中发生异常, 可能导致请求或响应对象"泄露" (并非真的泄露, 指示此流程可能无法回收这两个对象)
std::make_shared<flame::coroutine>()
->stack(php::callable([this, req, res, res_ptr, ptr] (php::parameters& params) {
if(res_ptr->status_ & RESPONSE_STATUS_FINISHED) {
// 1. 若协程结束时, 响应已经完毕, 则直接恢复复用连接
boost::asio::post(context, std::bind(&handler::handle, ptr, boost::system::error_code(), 0));
}else{
// 2. 还未完成, 标记脱离响应 (在各 writer 中需要对此种情况恢复 HANDLER 复用连接)
res_ptr->status_ |= RESPONSE_STATUS_DETACHED;
}
return nullptr;
}))
// after 处理
->stack(php::callable([this, req, res, ptr] (php::parameters& params) -> php::value {
auto iafter = svr_->cb_.find("after");
if(iafter != svr_->cb_.end()) {
// 确认是否匹配了目标处理器
std::string route = req.get("method");
route.push_back(':');
route.append(req.get("path"));
auto ipath = svr_->cb_.find(route);
return iafter->second.call({req, res, ipath != svr_->cb_.end()});
}
return nullptr;
}))
// path 处理
->stack(php::callable([this, req, res, ptr] (php::parameters& params) -> php::value {
// 执行前计算并重新查找目标处理器(允许用户在 before 中进行更改)
std::string route = req.get("method");
route.push_back(':');
route.append(req.get("path"));
auto ipath = svr_->cb_.find(route);
if(ipath != svr_->cb_.end()) {
return ipath->second.call({req, res});
}
return nullptr;
}))
// before 处理
->start(php::callable([this, req, res, ptr] (php::parameters& params) -> php::value {
auto ibefore = svr_->cb_.find("before");
if(ibefore != svr_->cb_.end()) {
// 确认是否匹配了目标处理器
std::string route = req.get("method");
route.push_back(':');
route.append(req.get("path"));
auto ipath = svr_->cb_.find(route);
return ibefore->second.call({req, res, ipath != svr_->cb_.end()});
}
return nullptr;
}));
};
// 此处恢复可能存在两种可能:
// 1. 上述 stack 中回调 (Content-Length 响应);
// 2. server_response::end() 后回调 (Chunked 响应);
if(error == boost::asio::error::eof || error == boost::asio::error::broken_pipe || error == boost::asio::error::connection_reset) {
n = 0; // 客户端连接关闭, 标志无需 keepalive
}else if(error) {
n = 0;
co_->fail(error);
}
} while(n > 0); //
}}
}
}
| 37.104762
| 135
| 0.600103
|
halivor
|
78ac704dfcbf2ab4148780997d8e21784de22e1f
| 3,269
|
hpp
|
C++
|
include/lapack/lacpy.hpp
|
tlapack/tlapack
|
18840a2a4e3bad4384baf4b3a2204ad54246aefa
|
[
"BSD-3-Clause"
] | 3
|
2021-06-09T13:47:13.000Z
|
2022-02-08T01:13:15.000Z
|
include/lapack/lacpy.hpp
|
weslleyspereira/tlapack
|
18840a2a4e3bad4384baf4b3a2204ad54246aefa
|
[
"BSD-3-Clause"
] | 17
|
2021-07-01T15:05:15.000Z
|
2022-03-31T20:37:10.000Z
|
include/lapack/lacpy.hpp
|
weslleyspereira/tlapack
|
18840a2a4e3bad4384baf4b3a2204ad54246aefa
|
[
"BSD-3-Clause"
] | 4
|
2021-06-09T13:46:38.000Z
|
2022-03-21T13:48:31.000Z
|
/// @file lacpy.hpp
/// @author Weslley S Pereira, University of Colorado Denver, USA
/// Adapted from @see https://github.com/langou/latl/blob/master/include/lacpy.h
//
// Copyright (c) 2012-2021, University of Colorado Denver. All rights reserved.
//
// This file is part of <T>LAPACK.
// <T>LAPACK is free software: you can redistribute it and/or modify it under
// the terms of the BSD 3-Clause license. See the accompanying LICENSE file.
#ifndef __LACPY_HH__
#define __LACPY_HH__
#include "lapack/types.hpp"
namespace lapack {
/** Copies a real matrix from A to B where A is either a full, upper triangular or lower triangular matrix.
*
* @param[in] uplo Specifies whether the matrix A is upper or lower triangular:
*
* 'U': A is assumed to be upper triangular; elements below the diagonal are not referenced.
* 'L': A is assumed to be lower triangular; elements above the diagonal are not referenced.
* otherwise, A is assumed to be a full matrix.
* @param[in] m The number of rows of the matrix A.
* @param[in] n The number of columns of the matrix A.
* @param[out] A Pointer to matrix A.
* @param[in] lda Column length of the matrix A.
* @param[out] B Pointer to matrix B.
* @param[in] ldb Column length of the matrix B.
*
* @ingroup auxiliary
*/
template< typename TA, typename TB >
void lacpy(
Uplo uplo, blas::idx_t m, blas::idx_t n,
TA* A, blas::idx_t lda,
TB* B, blas::idx_t ldb )
{
#define A(i_, j_) A[ (i_) + (j_)*lda ]
#define B(i_, j_) B[ (i_) + (j_)*ldb ]
if (uplo == Uplo::Upper) {
// Set the strictly upper triangular or trapezoidal part of B
for (idx_t j = 0; j < n; ++j) {
const idx_t M = std::min<idx_t>( m, j+1 );
for (idx_t i = 0; i < M; ++i)
B(i,j) = A(i,j);
}
}
else if (uplo == Uplo::Lower) {
// Set the strictly lower triangular or trapezoidal part of B
const idx_t N = std::min(m,n);
for (idx_t j = 0; j < N; ++j)
for (idx_t i = j; i < m; ++i)
B(i,j) = A(i,j);
}
else {
// Set the whole m-by-n matrix B
for (idx_t j = 0; j < n; ++j)
for (idx_t i = 0; i < m; ++i)
B(i,j) = A(i,j);
}
#undef A
#undef B
}
/** Copies a real matrix from A to B where A is either a full, upper triangular or lower triangular matrix.
*
* @param[in] matrixtype :
*
* 'U': A is assumed to be upper triangular; elements below the diagonal are not referenced.
* 'L': A is assumed to be lower triangular; elements above the diagonal are not referenced.
* otherwise, A is assumed to be a full matrix.
*
* @see lacpy( Uplo, blas::idx_t, blas::idx_t, TA*, blas::idx_t, TB* B, blas::idx_t )
*
* @ingroup auxiliary
*/
template< typename TA, typename TB >
void inline lacpy(
MatrixType matrixtype, blas::idx_t m, blas::idx_t n,
TA* A, blas::idx_t lda,
TB* B, blas::idx_t ldb )
{
if (matrixtype == MatrixType::Upper) {
lacpy(Uplo::Upper, m, n, A, lda, B, ldb);
} else if (matrixtype == MatrixType::Lower) {
lacpy(Uplo::Lower, m, n, A, lda, B, ldb);
} else {
lacpy(Uplo::General, m, n, A, lda, B, ldb);
}
}
}
#endif // __LACPY_HH__
| 33.020202
| 107
| 0.603243
|
tlapack
|
78b4b2ef5968a9199d290d7f204e7f4ffa66cffe
| 27,537
|
cpp
|
C++
|
openstudiocore/src/model/Loop.cpp
|
bobzabcik/OpenStudio
|
858321dc0ad8d572de15858d2ae487b029a8d847
|
[
"blessing"
] | null | null | null |
openstudiocore/src/model/Loop.cpp
|
bobzabcik/OpenStudio
|
858321dc0ad8d572de15858d2ae487b029a8d847
|
[
"blessing"
] | null | null | null |
openstudiocore/src/model/Loop.cpp
|
bobzabcik/OpenStudio
|
858321dc0ad8d572de15858d2ae487b029a8d847
|
[
"blessing"
] | null | null | null |
/**********************************************************************
* Copyright (c) 2008-2013, Alliance for Sustainable Energy.
* All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
**********************************************************************/
#include <model/Loop.hpp>
#include <model/Loop_Impl.hpp>
#include <model/Node.hpp>
#include <model/Node_Impl.hpp>
#include <model/ThermalZone.hpp>
#include <model/ThermalZone_Impl.hpp>
#include <model/PortList.hpp>
#include <model/PortList_Impl.hpp>
#include <model/Splitter.hpp>
#include <model/Splitter_Impl.hpp>
#include <model/Mixer.hpp>
#include <model/Mixer_Impl.hpp>
#include <model/StraightComponent.hpp>
#include <model/StraightComponent_Impl.hpp>
#include <model/WaterToAirComponent.hpp>
#include <model/WaterToAirComponent_Impl.hpp>
#include <model/WaterToWaterComponent.hpp>
#include <model/WaterToWaterComponent_Impl.hpp>
#include <model/AirLoopHVACOutdoorAirSystem.hpp>
#include <model/AirLoopHVACOutdoorAirSystem_Impl.hpp>
#include <model/Model.hpp>
#include <utilities/core/Assert.hpp>
namespace openstudio {
namespace model {
namespace detail {
Loop_Impl::Loop_Impl(IddObjectType type, Model_Impl* model)
: ParentObject_Impl(type,model)
{
}
Loop_Impl::Loop_Impl(const IdfObject& idfObject, Model_Impl* model, bool keepHandle)
: ParentObject_Impl(idfObject, model, keepHandle)
{
}
Loop_Impl::Loop_Impl(
const openstudio::detail::WorkspaceObject_Impl& other,
Model_Impl* model,
bool keepHandle)
: ParentObject_Impl(other,model,keepHandle)
{
}
Loop_Impl::Loop_Impl(const Loop_Impl& other,
Model_Impl* model,
bool keepHandles)
: ParentObject_Impl(other,model,keepHandles)
{
}
const std::vector<std::string>& Loop_Impl::outputVariableNames() const
{
static std::vector<std::string> result;
if (result.empty())
{
}
return result;
}
std::vector<openstudio::IdfObject> Loop_Impl::remove()
{
//ModelObjectVector modelObjects;
//ModelObjectVector::iterator it;
//modelObjects = this->supplyComponents();
//for(it = modelObjects.begin();
// it != modelObjects.end();
// it++)
//{
// if( it->optionalCast<Node>() ) continue;
// it->remove();
//}
//modelObjects = this->demandComponents();
//for(it = modelObjects.begin();
// it != modelObjects.end();
// it++)
//{
// it->remove();
//}
return ParentObject_Impl::remove();
}
OptionalModelObject Loop_Impl::component(openstudio::Handle handle)
{
OptionalModelObject result;
ModelObjectVector allComponents = components();
ModelObjectVector::iterator it;
for( it = allComponents.begin();
it != allComponents.end();
it++ )
{
if( it->handle() == handle )
{
return OptionalModelObject(*it);
}
}
return result;
}
boost::optional<ModelObject> Loop_Impl::demandComponent(openstudio::Handle handle)
{
OptionalModelObject result;
ModelObjectVector allComponents = demandComponents();
ModelObjectVector::iterator it;
for( it = allComponents.begin();
it != allComponents.end();
it++ )
{
if( it->handle() == handle )
{
return OptionalModelObject(*it);
}
}
return result;
}
boost::optional<ModelObject> Loop_Impl::supplyComponent(openstudio::Handle handle)
{
OptionalModelObject result;
ModelObjectVector allComponents = supplyComponents();
ModelObjectVector::iterator it;
for( it = allComponents.begin();
it != allComponents.end();
it++ )
{
if( it->handle() == handle )
{
return OptionalModelObject(*it);
}
}
return result;
}
ModelObject Loop_Impl::clone(Model model) const
{
return ParentObject_Impl::clone(model);
}
std::vector<ModelObject> Loop_Impl::children() const
{
return std::vector<ModelObject>();
}
std::vector<ModelObject> Loop_Impl::supplyComponents(std::vector<HVACComponent> inletComps,
std::vector<HVACComponent> outletComps,
openstudio::IddObjectType type
)
{
return std::vector<ModelObject>();
}
std::vector<ModelObject> Loop_Impl::demandComponents(std::vector<HVACComponent> inletComps,
std::vector<HVACComponent> outletComps,
openstudio::IddObjectType type
)
{
return std::vector<ModelObject>();
}
Node Loop_Impl::supplyInletNode() const
{
return Node(model());
}
Node Loop_Impl::supplyOutletNode() const
{
return Node(model());
}
Node Loop_Impl::demandInletNode() const
{
return Node(model());
}
Node Loop_Impl::demandOutletNode() const
{
return Node(model());
}
boost::optional<ModelObject> Loop_Impl::supplyInletNodeAsModelObject() {
OptionalModelObject result = supplyInletNode();
return result;
}
boost::optional<ModelObject> Loop_Impl::supplyOutletNodeAsModelObject() {
OptionalModelObject result = supplyOutletNode();
return result;
}
boost::optional<ModelObject> Loop_Impl::demandInletNodeAsModelObject() {
OptionalModelObject result = demandInletNode();
return result;
}
boost::optional<ModelObject> Loop_Impl::demandOutletNodeAsModelObject() {
OptionalModelObject result = demandOutletNode();
return result;
}
std::vector<ModelObject> Loop_Impl::demandComponents( HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type )
{
std::vector<ModelObject> modelObjects;
OptionalModelObject modelObject(inletComp);
bool outletNodeFound = false;
bool isPlantLoop = false;
if( this->iddObject().type() == IddObjectType::OS_PlantLoop )
{
isPlantLoop = true;
}
while(modelObject)
{
if(OptionalNode node = modelObject->optionalCast<Node>())
{
modelObjects.push_back(*node);
if( *node == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = node->outletModelObject();
}
}
else if(OptionalStraightComponent comp = modelObject->optionalCast<StraightComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = comp->outletModelObject();
}
}
else if(OptionalPortList comp = modelObject->optionalCast<PortList>())
{
if( boost::optional<ThermalZone> tz = comp->thermalZone() )
{
modelObjects.push_back(*tz);
if( *tz == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = tz->returnAirModelObject();
}
}
}
else if(OptionalMixer mixer = modelObject->optionalCast<Mixer>())
{
modelObjects.push_back(*mixer);
if( *mixer == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = mixer->outletModelObject();
}
}
else if(OptionalWaterToAirComponent comp = modelObject->optionalCast<WaterToAirComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
if( isPlantLoop )
{
modelObject = comp->waterOutletModelObject();
}
else
{
modelObject = comp->airOutletModelObject();
}
}
}
else if(OptionalWaterToWaterComponent comp = modelObject->optionalCast<WaterToWaterComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = comp->demandOutletModelObject();
}
}
else if(OptionalSplitter splitter = modelObject->optionalCast<Splitter>())
{
modelObject = boost::none;
std::vector<ModelObject> allBranchModelObjects;
std::vector<ModelObject> thisBranchModelObjects;
modelObjects.push_back(*splitter);
if( *splitter == outletComp )
{
outletNodeFound = true;
break;
}
std::vector<ModelObject> outletModelObjects = splitter->outletModelObjects();
for( std::vector<ModelObject>::iterator it = outletModelObjects.begin();
it != outletModelObjects.end();
it++ )
{
thisBranchModelObjects.clear();
OptionalModelObject branchObject = OptionalModelObject(*it);
while(branchObject)
{
if( OptionalNode node = branchObject->optionalCast<Node>() )
{
thisBranchModelObjects.push_back( node.get() );
allBranchModelObjects.push_back( node.get() );
if( *node == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = node->outletModelObject();
}
}
else if(OptionalStraightComponent comp = branchObject->optionalCast<StraightComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = comp->outletModelObject();
}
}
else if(OptionalPortList comp = branchObject->optionalCast<PortList>())
{
if( boost::optional<ThermalZone> tz = comp->thermalZone() )
{
thisBranchModelObjects.push_back( tz.get() );
allBranchModelObjects.push_back( tz.get() );
if( *tz == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = tz->returnAirModelObject();
}
}
}
else if(OptionalWaterToAirComponent comp = branchObject->optionalCast<WaterToAirComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
if( isPlantLoop )
{
branchObject = comp->waterOutletModelObject();
}
else
{
branchObject = comp->airOutletModelObject();
}
}
}
else if(OptionalWaterToWaterComponent comp = branchObject->optionalCast<WaterToWaterComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = comp->demandOutletModelObject();
}
}
else if(OptionalMixer mixer = branchObject->optionalCast<Mixer>() )
{
modelObject = mixer;
break;
}
else
{
break;
// Log unhandled component
}
}
if( outletNodeFound ) { break; }
}
if( outletNodeFound )
{
modelObjects.insert( modelObjects.end(),thisBranchModelObjects.begin(), thisBranchModelObjects.end() );
break;
}
else
{
modelObjects.insert( modelObjects.end(),allBranchModelObjects.begin(), allBranchModelObjects.end() );
}
}
else
{
modelObject = boost::none;
break;
// Log unhandled component
}
}
// Filter modelObjects for type
if( type != IddObjectType::Catchall )
{
std::vector<ModelObject> reducedModelObjects;
std::vector<ModelObject>::iterator it;
for(it = modelObjects.begin();
it != modelObjects.end();
it++)
{
if(it->iddObject().type() == type)
{
reducedModelObjects.push_back(*it);
}
}
modelObjects = reducedModelObjects;
}
if( outletNodeFound )
{
return modelObjects;
}
else
{
return std::vector<ModelObject>();
}
}
std::vector<ModelObject> Loop_Impl::supplyComponents(openstudio::IddObjectType type)
{
return supplyComponents( supplyInletNode(),
supplyOutletNode(),
type );
}
std::vector<ModelObject> Loop_Impl::demandComponents(openstudio::IddObjectType type)
{
return demandComponents( demandInletNode(),
demandOutletNode(),
type );
}
std::vector<ModelObject> Loop_Impl::components(openstudio::IddObjectType type)
{
std::vector<ModelObject> result;
result = this->supplyComponents( type );
std::vector<ModelObject> demandComponents = this->demandComponents( type );
result.insert(result.end(),demandComponents.begin(),demandComponents.end());
return result;
}
std::vector<ModelObject> Loop_Impl::supplyComponents( HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type)
{
std::vector<ModelObject> modelObjects;
OptionalModelObject modelObject(inletComp);
bool outletNodeFound = false;
bool isPlantLoop = false;
if( this->iddObject().type() == IddObjectType::OS_PlantLoop )
{
isPlantLoop = true;
}
while(modelObject)
{
if(OptionalNode node = modelObject->optionalCast<Node>())
{
modelObjects.push_back(*node);
if( *node == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = node->outletModelObject();
}
}
else if(OptionalStraightComponent comp = modelObject->optionalCast<StraightComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = comp->outletModelObject();
}
}
else if(OptionalThermalZone comp = modelObject->optionalCast<ThermalZone>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = comp->returnAirModelObject();
}
}
else if(OptionalMixer mixer = modelObject->optionalCast<Mixer>())
{
modelObjects.push_back(*mixer);
if( *mixer == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = mixer->outletModelObject();
}
}
else if(OptionalWaterToAirComponent comp = modelObject->optionalCast<WaterToAirComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
if( isPlantLoop )
{
modelObject = comp->waterOutletModelObject();
}
else
{
modelObject = comp->airOutletModelObject();
}
}
}
else if(OptionalWaterToWaterComponent comp = modelObject->optionalCast<WaterToWaterComponent>())
{
modelObjects.push_back(*comp);
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = comp->supplyOutletModelObject();
}
}
else if(OptionalAirLoopHVACOutdoorAirSystem mixer = modelObject->optionalCast<AirLoopHVACOutdoorAirSystem>())
{
modelObjects.push_back(*mixer);
if( *mixer == outletComp )
{
outletNodeFound = true;
break;
}
else
{
modelObject = mixer->mixedAirModelObject();
}
}
else if(OptionalSplitter splitter = modelObject->optionalCast<Splitter>())
{
modelObject = boost::none;
std::vector<ModelObject> allBranchModelObjects;
std::vector<ModelObject> thisBranchModelObjects;
modelObjects.push_back(*splitter);
if( *splitter == outletComp )
{
outletNodeFound = true;
break;
}
std::vector<ModelObject> outletModelObjects = splitter->outletModelObjects();
for( std::vector<ModelObject>::iterator it = outletModelObjects.begin();
it != outletModelObjects.end();
it++ )
{
thisBranchModelObjects.clear();
OptionalModelObject branchObject = OptionalModelObject(*it);
while(branchObject)
{
if( OptionalNode node = branchObject->optionalCast<Node>() )
{
thisBranchModelObjects.push_back( node.get() );
allBranchModelObjects.push_back( node.get() );
if( *node == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = node->outletModelObject();
}
}
else if(OptionalStraightComponent comp = branchObject->optionalCast<StraightComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = comp->outletModelObject();
}
}
else if(OptionalThermalZone comp = branchObject->optionalCast<ThermalZone>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = comp->returnAirModelObject();
}
}
else if(OptionalWaterToAirComponent comp = branchObject->optionalCast<WaterToAirComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
if( isPlantLoop )
{
branchObject = comp->waterOutletModelObject();
}
else
{
branchObject = comp->airOutletModelObject();
}
}
}
else if(OptionalWaterToWaterComponent comp = branchObject->optionalCast<WaterToWaterComponent>())
{
thisBranchModelObjects.push_back( comp.get() );
allBranchModelObjects.push_back( comp.get() );
if( *comp == outletComp )
{
outletNodeFound = true;
break;
}
else
{
branchObject = comp->supplyOutletModelObject();
}
}
else if(OptionalMixer mixer = branchObject->optionalCast<Mixer>() )
{
modelObject = mixer;
break;
}
else
{
break;
// Log unhandled component
}
}
if( outletNodeFound ) { break; }
}
if( outletNodeFound )
{
modelObjects.insert( modelObjects.end(),thisBranchModelObjects.begin(), thisBranchModelObjects.end() );
break;
}
else
{
modelObjects.insert( modelObjects.end(),allBranchModelObjects.begin(), allBranchModelObjects.end() );
}
}
else
{
modelObject = boost::none;
break;
// Log unhandled component
}
}
// Filter modelObjects for type
if( type != IddObjectType::Catchall )
{
std::vector<ModelObject> reducedModelObjects;
std::vector<ModelObject>::iterator it;
for(it = modelObjects.begin();
it != modelObjects.end();
it++)
{
if(it->iddObject().type() == type)
{
reducedModelObjects.push_back(*it);
}
}
modelObjects = reducedModelObjects;
}
if( outletNodeFound )
{
return modelObjects;
}
else
{
return std::vector<ModelObject>();
}
}
std::vector<ModelObject> Loop_Impl::components(HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type)
{
if( ( supplyComponent(inletComp.handle()) && supplyComponent(outletComp.handle()) ) )
{
return supplyComponents(inletComp,outletComp,type);
}
else if( ( demandComponent(inletComp.handle()) && demandComponent(outletComp.handle()) ) )
{
return demandComponents(inletComp,outletComp,type);
}
return std::vector<ModelObject>();
}
} // detail
Loop::Loop(IddObjectType type,const Model& model)
: ParentObject(type,model)
{
OS_ASSERT(getImpl<detail::Loop_Impl>());
}
Loop::Loop(boost::shared_ptr<detail::Loop_Impl> p)
: ParentObject(p)
{}
std::vector<IdfObject> Loop::remove()
{
return getImpl<detail::Loop_Impl>()->remove();
}
std::vector<ModelObject> Loop::components(openstudio::IddObjectType type)
{
return getImpl<detail::Loop_Impl>()->components( type );
}
std::vector<ModelObject> Loop::components(HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type)
{
return getImpl<detail::Loop_Impl>()->components( inletComp, outletComp, type);
}
boost::optional<ModelObject> Loop::component(openstudio::Handle handle)
{
return getImpl<detail::Loop_Impl>()->component( handle );
}
std::vector<ModelObject> Loop::supplyComponents(std::vector<HVACComponent> inletComps,
std::vector<HVACComponent> outletComps,
openstudio::IddObjectType type
)
{
return getImpl<detail::Loop_Impl>()->supplyComponents( inletComps, outletComps, type);
}
std::vector<ModelObject> Loop::supplyComponents(HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type)
{
return getImpl<detail::Loop_Impl>()->supplyComponents( inletComp, outletComp, type);
}
std::vector<ModelObject> Loop::supplyComponents(openstudio::IddObjectType type)
{
return getImpl<detail::Loop_Impl>()->supplyComponents(type);
}
std::vector<ModelObject> Loop::demandComponents(std::vector<HVACComponent> inletComps,
std::vector<HVACComponent> outletComps,
openstudio::IddObjectType type
)
{
return getImpl<detail::Loop_Impl>()->demandComponents( inletComps, outletComps, type);
}
std::vector<ModelObject> Loop::demandComponents( HVACComponent inletComp,
HVACComponent outletComp,
openstudio::IddObjectType type )
{
return getImpl<detail::Loop_Impl>()->demandComponents( inletComp, outletComp, type);
}
std::vector<ModelObject> Loop::demandComponents(openstudio::IddObjectType type)
{
return getImpl<detail::Loop_Impl>()->demandComponents(type);
}
ModelObject Loop::clone(Model model) const
{
return getImpl<detail::Loop_Impl>()->clone( model );
}
std::vector<ModelObject> Loop::children() const
{
return getImpl<detail::Loop_Impl>()->children();
}
boost::optional<ModelObject> Loop::demandComponent(openstudio::Handle handle)
{
return getImpl<detail::Loop_Impl>()->demandComponent( handle );
}
boost::optional<ModelObject> Loop::supplyComponent(openstudio::Handle handle)
{
return getImpl<detail::Loop_Impl>()->supplyComponent( handle );
}
Node Loop::supplyInletNode()
{
return getImpl<detail::Loop_Impl>()->supplyInletNode();
}
Node Loop::supplyOutletNode()
{
return getImpl<detail::Loop_Impl>()->supplyOutletNode();
}
Node Loop::demandInletNode()
{
return getImpl<detail::Loop_Impl>()->demandInletNode();
}
Node Loop::demandOutletNode()
{
return getImpl<detail::Loop_Impl>()->demandOutletNode();
}
Splitter Loop::demandSplitter() const
{
return getImpl<detail::Loop_Impl>()->demandSplitter();
}
Mixer Loop::demandMixer() const
{
return getImpl<detail::Loop_Impl>()->demandMixer();
}
} // model
} // openstudio
| 28.895068
| 116
| 0.54454
|
bobzabcik
|
78b512ccb2d3d385533bbc161e367dfb25c0add0
| 75,307
|
hpp
|
C++
|
contrib/autoboost/autoboost/preprocessor/comparison/not_equal.hpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 87
|
2015-01-18T00:43:06.000Z
|
2022-02-11T17:40:50.000Z
|
contrib/autoboost/autoboost/preprocessor/comparison/not_equal.hpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 274
|
2015-01-03T04:50:49.000Z
|
2021-03-08T09:01:09.000Z
|
contrib/autoboost/autoboost/preprocessor/comparison/not_equal.hpp
|
CaseyCarter/autowiring
|
48e95a71308318c8ffb7ed1348e034fd9110f70c
|
[
"Apache-2.0"
] | 15
|
2015-09-30T20:58:43.000Z
|
2020-12-19T21:24:56.000Z
|
# /* Copyright (C) 2001
# * Housemarque Oy
# * http://www.housemarque.com
# *
# * Distributed under the Boost Software License, Version 1.0. (See
# * accompanying file LICENSE_1_0.txt or copy at
# * http://www.boost.org/LICENSE_1_0.txt)
# */
#
# /* Revised by Paul Mensonides (2002) */
#
# /* See http://www.boost.org for most recent version. */
#
# ifndef AUTOBOOST_PREPROCESSOR_COMPARISON_NOT_EQUAL_HPP
# define AUTOBOOST_PREPROCESSOR_COMPARISON_NOT_EQUAL_HPP
#
# include <autoboost/preprocessor/cat.hpp>
# include <autoboost/preprocessor/config/config.hpp>
# include <autoboost/preprocessor/control/iif.hpp>
#
# /* AUTOBOOST_PP_NOT_EQUAL */
#
# if ~AUTOBOOST_PP_CONFIG_FLAGS() & AUTOBOOST_PP_CONFIG_MWCC()
# define AUTOBOOST_PP_NOT_EQUAL(x, y) AUTOBOOST_PP_NOT_EQUAL_I(x, y)
# else
# define AUTOBOOST_PP_NOT_EQUAL(x, y) AUTOBOOST_PP_NOT_EQUAL_OO((x, y))
# define AUTOBOOST_PP_NOT_EQUAL_OO(par) AUTOBOOST_PP_NOT_EQUAL_I ## par
# endif
#
# define AUTOBOOST_PP_NOT_EQUAL_I(x, y) AUTOBOOST_PP_CAT(AUTOBOOST_PP_NOT_EQUAL_CHECK_, AUTOBOOST_PP_NOT_EQUAL_ ## x(0, AUTOBOOST_PP_NOT_EQUAL_ ## y))
#
# /* AUTOBOOST_PP_NOT_EQUAL_D */
#
# define AUTOBOOST_PP_NOT_EQUAL_D(d, x, y) AUTOBOOST_PP_NOT_EQUAL(x, y)
#
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NIL 1
#
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_0(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_1(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_2(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_3(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_4(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_5(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_6(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_7(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_8(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_9(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_10(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_11(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_12(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_13(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_14(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_15(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_16(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_17(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_18(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_19(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_20(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_21(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_22(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_23(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_24(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_25(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_26(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_27(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_28(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_29(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_30(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_31(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_32(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_33(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_34(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_35(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_36(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_37(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_38(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_39(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_40(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_41(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_42(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_43(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_44(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_45(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_46(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_47(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_48(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_49(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_50(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_51(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_52(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_53(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_54(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_55(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_56(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_57(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_58(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_59(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_60(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_61(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_62(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_63(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_64(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_65(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_66(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_67(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_68(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_69(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_70(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_71(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_72(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_73(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_74(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_75(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_76(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_77(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_78(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_79(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_80(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_81(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_82(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_83(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_84(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_85(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_86(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_87(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_88(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_89(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_90(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_91(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_92(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_93(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_94(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_95(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_96(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_97(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_98(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_99(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_100(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_101(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_102(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_103(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_104(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_105(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_106(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_107(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_108(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_109(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_110(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_111(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_112(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_113(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_114(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_115(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_116(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_117(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_118(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_119(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_120(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_121(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_122(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_123(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_124(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_125(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_126(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_127(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_128(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_129(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_130(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_131(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_132(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_133(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_134(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_135(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_136(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_137(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_138(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_139(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_140(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_141(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_142(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_143(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_144(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_145(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_146(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_147(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_148(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_149(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_150(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_151(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_152(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_153(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_154(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_155(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_156(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_157(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_158(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_159(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_160(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_161(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_162(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_163(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_164(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_165(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_166(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_167(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_168(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_169(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_170(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_171(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_172(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_173(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_174(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_175(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_176(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_177(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_178(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_179(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_180(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_181(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_182(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_183(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_184(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_185(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_186(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_187(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_188(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_189(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_190(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_191(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_192(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_193(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_194(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_195(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_196(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_197(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_198(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_199(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_200(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_201(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_202(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_203(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_204(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_205(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_206(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_207(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_208(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_209(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_210(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_211(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_212(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_213(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_214(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_215(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_216(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_217(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_218(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_219(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_220(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_221(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_222(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_223(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_224(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_225(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_226(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_227(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_228(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_229(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_230(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_231(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_232(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_233(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_234(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_235(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_236(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_237(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_238(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_239(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_240(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_241(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_242(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_243(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_244(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_245(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_246(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_247(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_248(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_249(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_250(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_251(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_252(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_253(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_254(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_255(c, y) 0
# define AUTOBOOST_PP_NOT_EQUAL_CHECK_AUTOBOOST_PP_NOT_EQUAL_256(c, y) 0
#
#if ~AUTOBOOST_PP_CONFIG_FLAGS() & AUTOBOOST_PP_CONFIG_DMC()
# define AUTOBOOST_PP_NOT_EQUAL_0(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_1(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_2(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_3(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_4(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_5(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_6(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_7(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_8(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_9(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_10(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_11(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_12(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_13(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_14(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_15(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_16(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_17(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_18(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_19(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_20(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_21(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_22(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_23(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_24(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_25(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_26(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_27(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_28(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_29(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_30(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_31(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_32(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_33(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_34(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_35(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_36(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_37(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_38(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_39(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_40(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_41(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_42(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_43(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_44(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_45(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_46(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_47(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_48(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_49(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_50(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_51(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_52(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_53(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_54(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_55(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_56(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_57(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_58(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_59(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_60(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_61(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_62(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_63(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_64(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_65(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_66(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_67(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_68(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_69(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_70(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_71(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_72(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_73(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_74(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_75(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_76(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_77(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_78(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_79(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_80(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_81(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_82(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_83(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_84(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_85(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_86(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_87(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_88(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_89(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_90(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_91(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_92(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_93(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_94(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_95(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_96(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_97(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_98(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_99(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_100(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_101(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_102(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_103(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_104(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_105(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_106(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_107(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_108(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_109(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_110(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_111(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_112(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_113(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_114(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_115(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_116(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_117(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_118(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_119(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_120(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_121(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_122(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_123(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_124(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_125(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_126(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_127(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_128(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_129(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_130(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_131(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_132(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_133(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_134(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_135(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_136(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_137(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_138(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_139(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_140(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_141(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_142(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_143(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_144(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_145(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_146(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_147(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_148(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_149(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_150(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_151(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_152(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_153(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_154(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_155(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_156(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_157(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_158(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_159(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_160(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_161(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_162(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_163(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_164(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_165(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_166(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_167(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_168(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_169(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_170(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_171(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_172(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_173(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_174(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_175(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_176(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_177(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_178(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_179(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_180(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_181(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_182(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_183(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_184(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_185(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_186(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_187(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_188(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_189(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_190(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_191(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_192(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_193(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_194(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_195(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_196(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_197(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_198(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_199(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_200(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_201(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_202(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_203(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_204(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_205(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_206(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_207(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_208(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_209(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_210(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_211(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_212(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_213(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_214(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_215(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_216(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_217(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_218(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_219(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_220(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_221(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_222(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_223(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_224(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_225(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_226(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_227(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_228(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_229(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_230(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_231(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_232(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_233(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_234(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_235(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_236(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_237(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_238(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_239(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_240(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_241(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_242(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_243(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_244(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_245(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_246(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_247(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_248(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_249(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_250(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_251(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_252(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_253(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_254(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_255(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_256(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y(1, AUTOBOOST_PP_NIL))
# else
# define AUTOBOOST_PP_NOT_EQUAL_0(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_1(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_2(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_3(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_4(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_5(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_6(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_7(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_8(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_9(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_10(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_11(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_12(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_13(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_14(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_15(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_16(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_17(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_18(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_19(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_20(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_21(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_22(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_23(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_24(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_25(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_26(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_27(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_28(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_29(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_30(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_31(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_32(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_33(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_34(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_35(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_36(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_37(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_38(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_39(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_40(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_41(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_42(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_43(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_44(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_45(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_46(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_47(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_48(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_49(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_50(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_51(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_52(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_53(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_54(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_55(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_56(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_57(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_58(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_59(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_60(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_61(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_62(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_63(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_64(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_65(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_66(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_67(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_68(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_69(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_70(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_71(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_72(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_73(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_74(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_75(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_76(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_77(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_78(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_79(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_80(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_81(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_82(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_83(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_84(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_85(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_86(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_87(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_88(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_89(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_90(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_91(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_92(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_93(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_94(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_95(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_96(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_97(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_98(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_99(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_100(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_101(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_102(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_103(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_104(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_105(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_106(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_107(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_108(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_109(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_110(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_111(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_112(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_113(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_114(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_115(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_116(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_117(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_118(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_119(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_120(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_121(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_122(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_123(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_124(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_125(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_126(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_127(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_128(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_129(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_130(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_131(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_132(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_133(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_134(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_135(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_136(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_137(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_138(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_139(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_140(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_141(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_142(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_143(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_144(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_145(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_146(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_147(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_148(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_149(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_150(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_151(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_152(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_153(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_154(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_155(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_156(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_157(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_158(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_159(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_160(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_161(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_162(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_163(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_164(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_165(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_166(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_167(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_168(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_169(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_170(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_171(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_172(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_173(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_174(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_175(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_176(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_177(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_178(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_179(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_180(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_181(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_182(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_183(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_184(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_185(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_186(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_187(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_188(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_189(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_190(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_191(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_192(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_193(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_194(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_195(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_196(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_197(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_198(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_199(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_200(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_201(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_202(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_203(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_204(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_205(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_206(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_207(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_208(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_209(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_210(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_211(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_212(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_213(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_214(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_215(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_216(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_217(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_218(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_219(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_220(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_221(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_222(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_223(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_224(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_225(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_226(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_227(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_228(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_229(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_230(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_231(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_232(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_233(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_234(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_235(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_236(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_237(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_238(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_239(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_240(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_241(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_242(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_243(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_244(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_245(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_246(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_247(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_248(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_249(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_250(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_251(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_252(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_253(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_254(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_255(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# define AUTOBOOST_PP_NOT_EQUAL_256(c, y) AUTOBOOST_PP_IIF(c, AUTOBOOST_PP_NIL, y##(1, AUTOBOOST_PP_NIL))
# endif
#
# endif
| 92.401227
| 150
| 0.80792
|
CaseyCarter
|
78b65c2544c68f9f425054c8cd27655f7b258a75
| 1,904
|
cpp
|
C++
|
samples/Common/ObjLoader.cpp
|
SoulForMachine/GLSlayer
|
37a0fab90c4e2c3a22279cc93d39e8f3091b5e12
|
[
"MIT"
] | null | null | null |
samples/Common/ObjLoader.cpp
|
SoulForMachine/GLSlayer
|
37a0fab90c4e2c3a22279cc93d39e8f3091b5e12
|
[
"MIT"
] | 1
|
2017-10-24T12:19:52.000Z
|
2017-10-24T12:19:52.000Z
|
samples/Common/ObjLoader.cpp
|
SoulForMachine/GLSlayer
|
37a0fab90c4e2c3a22279cc93d39e8f3091b5e12
|
[
"MIT"
] | null | null | null |
#include "ObjLoader.h"
#include "Utils.h"
using namespace std;
using namespace math3d;
bool ObjLoader::Load(const char* file_name)
{
string full_path = GetFullPath(file_name);
FILE* file = fopen(full_path.c_str(), "rt");
if(!file)
return false;
const int BUF_SIZE = 1024;
char buf[BUF_SIZE];
while(!feof(file))
{
const char* str = fgets(buf, BUF_SIZE, file);
if(!str)
break;
if(strncmp(str, "vn", 2) == 0)
{
ObjVertex vertex;
int count = sscanf(str, "vn %f %f %f", &vertex.normal[0], &vertex.normal[1], &vertex.normal[2]);
if(count != 3)
{
Unload();
fclose(file);
return false;
}
_vertices.push_back(vertex);
}
else if(str[0] == 'v')
{
ObjVertex& vertex = _vertices[_vertices.size() - 1];
int count = sscanf(str, "v %f %f %f", &vertex.position[0], &vertex.position[1], &vertex.position[2]);
if(count != 3)
{
Unload();
fclose(file);
return false;
}
if(_vertices.size() == 1)
{
_minPt = _maxPt = _vertices[0].position;
}
else
{
vec3f position = _vertices[_vertices.size() - 1].position;
if(position.x < _minPt.x)
_minPt.x = position.x;
if(position.y < _minPt.y)
_minPt.y = position.y;
if(position.z < _minPt.z)
_minPt.z = position.z;
if(position.x > _maxPt.x)
_maxPt.x = position.x;
if(position.y > _maxPt.y)
_maxPt.y = position.y;
if(position.z > _maxPt.z)
_maxPt.z = position.z;
}
}
else if(str[0] == 'f')
{
unsigned int ind0, ind1, ind2;
int count = sscanf(str, "f %d//%d %d//%d %d//%d", &ind0, &ind0, &ind1, &ind1, &ind2, &ind2);
if(count != 6)
{
Unload();
fclose(file);
return false;
}
_indices.push_back(ind0 - 1);
_indices.push_back(ind1 - 1);
_indices.push_back(ind2 - 1);
}
}
fclose(file);
return true;
}
void ObjLoader::Unload()
{
_indices.clear();
_vertices.clear();
}
| 19.428571
| 104
| 0.588761
|
SoulForMachine
|
78b6795a106af9138907a2b5aa93f21b4b00001f
| 7,768
|
cpp
|
C++
|
test/parser_test.cpp
|
bsurmanski/wlc-ng
|
7c72a3172e910b2907a73957cc6cbd6477b2ea5e
|
[
"MIT"
] | null | null | null |
test/parser_test.cpp
|
bsurmanski/wlc-ng
|
7c72a3172e910b2907a73957cc6cbd6477b2ea5e
|
[
"MIT"
] | null | null | null |
test/parser_test.cpp
|
bsurmanski/wlc-ng
|
7c72a3172e910b2907a73957cc6cbd6477b2ea5e
|
[
"MIT"
] | null | null | null |
#include <gtest/gtest.h>
#include <stdio.h>
#include "ast/ast.hpp"
#include "common/string.hpp"
#include "io/environment.hpp"
#include "io/stringInput.hpp"
#include "lex/lexer.hpp"
#include "parse/parser.hpp"
#include "program.hpp"
#define TRY(X) { try { (X); } catch(std::exception &e) { printf("%s\n", e.what()); ADD_FAILURE(); }}
class TestParser : public testing::Test {
Parser *parser;
public:
Program *newDummyProgram() {
Environment *e = new Environment;
Program *p = new Program(e);
return p;
}
Parser *newStringParser(String str) {
Program *prog = newDummyProgram();
Lexer *lex = new Lexer(new StringInput(str));
return new Parser(prog, lex);
}
void TestStmt(String serialized_exp, String stmt_str) {
Parser *parser;
Stmt *stmt;
TRY({
parser = newStringParser(stmt_str);
stmt = parser->parseStmt();
EXPECT_EQ(serialized_exp, stmt->serialized());
delete stmt;
});
delete parser;
}
void TestExpr(String serialized_exp, String expr_str) {
Parser *parser;
Expr *expr;
TRY({
parser = newStringParser(expr_str);
expr = parser->parseExpr();
EXPECT_EQ(serialized_exp, expr->serialized());
delete expr;
});
delete parser;
}
void TestDecl(String serialized_exp, String decl_str) {
Parser *parser;
Decl *decl;
TRY({
parser = newStringParser(decl_str);
decl = parser->parseDecl();
EXPECT_EQ(serialized_exp, decl->serialized());
delete decl;
});
delete parser;
}
void TestType(String serialized_exp, String type_str) {
Parser *parser;
Type *type;
TRY({
parser = newStringParser(type_str);
type = parser->parseType();
EXPECT_EQ(serialized_exp, type->serialized());
});
delete parser;
}
virtual void OnTestStart(const testing::TestInfo &test_info) {
}
virtual void OnTestEnd(const testing::TestInfo &test_info) {
}
};
static Program *createDummyProgram() {
Environment *e = new Environment;
Program *p = new Program(e);
return p;
}
static Parser *createStringParser(String str) {
Program *prog = createDummyProgram();
Lexer *lex = new Lexer(new StringInput(str));
return new Parser(prog, lex);
}
TEST_F(TestParser, CompoundStmt) {
TestStmt("(stmts\n (var i int32 0)\n (if (lt (id i) 0)\n (set (id i) 5)))", "{\nint i = 0\nif(i < 0) i = 5\n}");
TestStmt("(stmts\n (var i int32 0)\n (if (lt (id i) 0)\n (set (id i) 5)))", "{int i = 0;if(i < 0) i = 5}");
}
TEST_F(TestParser, ReturnStmt) {
TestStmt("(return 0)", "return 0");
TestStmt("(return)", "return \n 0");
}
TEST_F(TestParser, PrimativeType) {
Parser *parser = NULL;
PrimativeType *type = NULL;
#define TEST_STR(EXP, STR) \
parser = createStringParser(STR);\
type = parser->parsePrimativeType();\
EXPECT_NE((Type*) NULL, type);\
if(type) {\
EXPECT_EQ(EXP, type->getKind());\
EXPECT_EQ(true, parser->getLexer()->eof());\
}\
delete parser;
TRY({
TEST_STR(PrimativeType::BOOL, "bool");
TEST_STR(PrimativeType::VOID, "void");
TEST_STR(PrimativeType::INT8, "char");
TEST_STR(PrimativeType::INT16, "short");
TEST_STR(PrimativeType::INT32, "int");
TEST_STR(PrimativeType::INT64, "long");
TEST_STR(PrimativeType::INT8, "int8");
TEST_STR(PrimativeType::INT16, "int16");
TEST_STR(PrimativeType::INT32, "int32");
TEST_STR(PrimativeType::INT64, "int64");
TEST_STR(PrimativeType::UINT8, "uchar");
TEST_STR(PrimativeType::UINT16, "ushort");
TEST_STR(PrimativeType::UINT32, "uint");
TEST_STR(PrimativeType::UINT64, "ulong");
TEST_STR(PrimativeType::UINT8, "uint8");
TEST_STR(PrimativeType::UINT16, "uint16");
TEST_STR(PrimativeType::UINT32, "uint32");
TEST_STR(PrimativeType::UINT64, "uint64");
TEST_STR(PrimativeType::FLOAT32, "float");
TEST_STR(PrimativeType::FLOAT64, "double");
TEST_STR(PrimativeType::FLOAT32, "float32");
TEST_STR(PrimativeType::FLOAT64, "float64");
});
#undef TEST_STR
TestType("bool", "bool");
TestType("void", "void");
TestType("int8", "int8");
TestType("int16", "int16");
TestType("int32", "int32");
TestType("int64", "int64");
TestType("uint8", "uint8");
TestType("uint16", "uint16");
TestType("uint32", "uint32");
TestType("uint64", "uint64");
TestType("float32", "float32");
TestType("float64", "float64");
}
TEST_F(TestParser, UnaryExpr) {
TestExpr("(preinc 1)", "++1");
TestExpr("(predec 1)", "--1");
TestExpr("(not null)", "!null");
TestExpr("(deref null)", "^null");
TestExpr("(ref null)", "&null");
}
TEST_F(TestParser, BinaryExpr) {
TestExpr("(add 1 1)", "1 + 1");
TestExpr("(add (add 1 2) 3)", "1 + 2 + 3");
TestExpr("(add 1 (mul 2 3))", "1 + 2 * 3");
TestExpr("(add 1 (mul (mul 2 3) 4))", "1 + 2 * 3 * 4");
TestExpr("(sub (add 1 (div 2 3)) 4)", "1 + 2 / 3 - 4");
}
TEST_F(TestParser, PostfixExpr) {
TestExpr("(postinc 1)", "1++");
TestExpr("(postdec 1)", "1--");
}
TEST_F(TestParser, IdExpr) {
TestExpr("(id myid)", "myid");
TestExpr("(id myid)", "myid ;");
}
TEST_F(TestParser, RetainExpr) {
TestExpr("(retain (id a))", "retain a");
}
TEST_F(TestParser, ReleaseExpr) {
TestExpr("(release (id a))", "release a");
}
TEST_F(TestParser, NewExpr) {
TestExpr("(new (type mytype))", "new mytype");
}
TEST_F(TestParser, DeleteExpr) {
TestExpr("(delete (id a))", "delete a");
}
TEST_F(TestParser, CallExpr) {
TestExpr("(call (id myfunc))", "myfunc()");
TestExpr("(call (id myfunc) 1 2 3 (id a) (id b))", "myfunc(1, 2, 3, a, b)");
}
TEST_F(TestParser, MemberExpr) {
TestExpr("(member (id a) (id b))", "a.b");
TestExpr("(member (member (id a) (id b)) (id c))", "a.b.c");
}
TEST_F(TestParser, IndexExpr) {
TestExpr("(index (id a) 0)", "a[0]");
TestExpr("(index (id abc) (add 1 2))", "abc[1 + 2]");
}
TEST_F(TestParser, PackExpr) {
TestExpr("(pack \"afile.txt\")", "pack \"afile.txt\"");
}
TEST_F(TestParser, CastExpr) {
TestExpr("(cast (id myexpr) int)", "int: myexpr");
}
TEST_F(TestParser, Literals) {
TestExpr("123", "123");
TestExpr("true", "true");
TestExpr("false", "false");
TestExpr("null", "null");
}
TEST_F(TestParser, ComplexExpr) {
TestExpr("(sub 3 (mul 1 2))", "3 - (1 * 2)");
TestExpr("(sub (mul 1 2) 3)", "(1 * 2) - 3");
TestExpr("(mul (add (id a) (id b)) (div 2 3))", "(a + b) * (2 / 3)");
TestExpr("(mul (neg (id a)) (neg (id b)))", "-a * -b");
}
TEST_F(TestParser, VarDecl) {
TestDecl("(var hello int8)", "int8 hello");
TestDecl("(var goodbye (ptr float32))", "float^ goodbye");
TestDecl("(var myvar int32)", "int myvar");
}
TEST_F(TestParser, FuncDecl) {
TestDecl("(func hello void (vars (var a int8))\n (break))", "void hello(int8 a) break");
TestDecl("(func hello void (vars (var a int8))\n (stmts\n (call (id printf) \"helloworld\")))", "void hello(int8 a) {\nprintf(\"helloworld\")\n}");
}
TEST_F(TestParser, TypeDecl) {
TestDecl("(struct mystruct (decls\n (var i int32)\n (var j int32)\n (var k (type mytype))))", "struct mystruct{\nint i\nint j\nmytype k\n}");
TestDecl("(struct mystruct (decls))", "struct mystruct{}");
TestDecl("(class myclass (id base) (decls))", "class myclass : base {}");
}
| 29.536122
| 155
| 0.575695
|
bsurmanski
|
78ba3f8deb89a55e2b4ac0a2aa4429e2a5311a2d
| 12,656
|
cpp
|
C++
|
plugins/mmstd_datatools/src/OverrideParticleBBox.cpp
|
azuki-monster/megamol
|
f5d75ae5630f9a71a7fbf81624bfd4f6b253c655
|
[
"BSD-3-Clause"
] | null | null | null |
plugins/mmstd_datatools/src/OverrideParticleBBox.cpp
|
azuki-monster/megamol
|
f5d75ae5630f9a71a7fbf81624bfd4f6b253c655
|
[
"BSD-3-Clause"
] | null | null | null |
plugins/mmstd_datatools/src/OverrideParticleBBox.cpp
|
azuki-monster/megamol
|
f5d75ae5630f9a71a7fbf81624bfd4f6b253c655
|
[
"BSD-3-Clause"
] | null | null | null |
/*
* OverrideParticleBBox.h
*
* Copyright (C) 2015 by S. Grottel
* Alle Rechte vorbehalten.
*/
#include "stdafx.h"
#include "OverrideParticleBBox.h"
#include <float.h>
#include "mmcore/param/BoolParam.h"
#include "mmcore/param/ButtonParam.h"
#include "mmcore/param/IntParam.h"
#include "mmcore/param/Vector3fParam.h"
#include "vislib/math/Point.h"
#include "vislib/math/ShallowPoint.h"
#include "mmcore/utility/log/Log.h"
using namespace megamol;
using namespace megamol::stdplugin;
VISLIB_FORCEINLINE vislib::math::ShallowPoint<float, 3> posFromXYZ(void* const ptr, size_t stride, size_t idx) {
return vislib::math::ShallowPoint<float, 3>(reinterpret_cast<float*>(reinterpret_cast<char*>(ptr) + idx * stride));
}
VISLIB_FORCEINLINE vislib::math::ShallowPoint<float, 3> posFromXYZR(void* const ptr, size_t stride, size_t idx) {
return vislib::math::ShallowPoint<float, 3>(reinterpret_cast<float*>(reinterpret_cast<char*>(ptr) + idx * stride));
}
// VISLIB_FORCEINLINE vislib::math::AbstractPoint<float, 3, float[3]> posFromXYZ_SHORT(void* const ptr , size_t stride,
// size_t idx) {
// const unsigned short *newPtr = reinterpret_cast< unsigned short *>(reinterpret_cast<const char *>(ptr) + idx *
// stride); return vislib::math::Point<float, 3>(newPtr[0], newPtr[1], newPtr[2]);
//}
typedef vislib::math::ShallowPoint<float, 3> (*posFromSomethingFunc)(void*, size_t, size_t);
/*
* datatools::OverrideParticleBBox::OverrideParticleBBox
*/
datatools::OverrideParticleBBox::OverrideParticleBBox(void)
: AbstractParticleManipulator("outData", "indata")
, overrideBBoxSlot("override", "Activates the overwrite of the bounding box")
, overrideLBBoxSlot("overrideLocalBBox", "Activates the overwrite of the local bounding box")
, bboxMinSlot("bbox::min", "The minimum values of the bounding box")
, bboxMaxSlot("bbox::max", "The maximum values of the bounding box")
, resetSlot("reset", "Resets the bounding box values to the incoming data")
, autocomputeSlot("autocompute::trigger", "Triggers the automatic computation of the bounding box")
, autocomputeSamplesSlot("autocompute::samples", "Number of samples for the automatic computation")
, autocomputeXSlot("autocompute::x", "Activates automatic computation of the x size")
, autocomputeYSlot("autocompute::y", "Activates automatic computation of the y size")
, autocomputeZSlot("autocompute::z", "Activates automatic computation of the z size") {
this->overrideBBoxSlot.SetParameter(new core::param::BoolParam(false));
this->MakeSlotAvailable(&this->overrideBBoxSlot);
this->overrideLBBoxSlot.SetParameter(new core::param::BoolParam(false));
this->MakeSlotAvailable(&this->overrideLBBoxSlot);
this->bboxMinSlot.SetParameter(new core::param::Vector3fParam(vislib::math::Vector<float, 3>(-1.0f, -1.0f, -1.0f)));
this->MakeSlotAvailable(&this->bboxMinSlot);
this->bboxMaxSlot.SetParameter(new core::param::Vector3fParam(vislib::math::Vector<float, 3>(1.0f, 1.0f, 1.0f)));
this->MakeSlotAvailable(&this->bboxMaxSlot);
this->resetSlot.SetParameter(new core::param::ButtonParam());
this->MakeSlotAvailable(&this->resetSlot);
this->autocomputeSlot.SetParameter(new core::param::ButtonParam());
this->MakeSlotAvailable(&this->autocomputeSlot);
this->autocomputeSamplesSlot.SetParameter(new core::param::IntParam(10, 0));
this->MakeSlotAvailable(&this->autocomputeSamplesSlot);
this->autocomputeXSlot.SetParameter(new core::param::BoolParam(true));
this->MakeSlotAvailable(&this->autocomputeXSlot);
this->autocomputeYSlot.SetParameter(new core::param::BoolParam(true));
this->MakeSlotAvailable(&this->autocomputeYSlot);
this->autocomputeZSlot.SetParameter(new core::param::BoolParam(true));
this->MakeSlotAvailable(&this->autocomputeZSlot);
}
/*
* datatools::OverrideParticleBBox::~OverrideParticleBBox
*/
datatools::OverrideParticleBBox::~OverrideParticleBBox(void) { this->Release(); }
/*
* datatools::OverrideParticleBBox::manipulateData
*/
bool datatools::OverrideParticleBBox::manipulateData(
megamol::core::moldyn::MultiParticleDataCall& outData, megamol::core::moldyn::MultiParticleDataCall& inData) {
return this->manipulateExtent(outData, inData); // because the actual implementations are identical
}
/*
* datatools::OverrideParticleBBox::manipulateExtent
*/
bool datatools::OverrideParticleBBox::manipulateExtent(
megamol::core::moldyn::MultiParticleDataCall& outData, megamol::core::moldyn::MultiParticleDataCall& inData) {
using megamol::core::moldyn::MultiParticleDataCall;
if (this->resetSlot.IsDirty()) {
this->resetSlot.ResetDirty();
this->bboxMinSlot.Param<core::param::Vector3fParam>()->SetValue(
inData.AccessBoundingBoxes().ObjectSpaceBBox().GetLeftBottomBack());
this->bboxMaxSlot.Param<core::param::Vector3fParam>()->SetValue(
inData.AccessBoundingBoxes().ObjectSpaceBBox().GetRightTopFront());
}
// if (this->autocomputeSlot.IsDirty()) {
// this->autocomputeSlot.ResetDirty();
// megamol::core::utility::log::Log::DefaultLog.WriteError("OverrideParticleBBox::Autocompute not implemented");
// // TODO: Implement
// float minX = FLT_MAX, minY = FLT_MAX, minZ = FLT_MAX;
// float maxX = -FLT_MAX, maxY = -FLT_MAX, maxZ = -FLT_MAX;
// for (size_t l = 0, max = inData.GetParticleListCount(); l < max; l++) {
// for (size_t p = 0, maxP = inData.AccessParticles(l).GetCount(); p < maxP; p++) {
// //inData.AccessParticles(l).GetVertexData()
// }
// }
//}
if (!(inData)(0)) return false;
outData = inData; // also transfers the unlocker to 'outData'
bool doX = this->autocomputeXSlot.Param<core::param::BoolParam>()->Value();
bool doY = this->autocomputeYSlot.Param<core::param::BoolParam>()->Value();
bool doZ = this->autocomputeZSlot.Param<core::param::BoolParam>()->Value();
int samples = this->autocomputeSamplesSlot.Param<core::param::IntParam>()->Value();
float rad = 0.0f;
float minX = std::numeric_limits<float>::max(), minY = std::numeric_limits<float>::max(),
minZ = std::numeric_limits<float>::max();
float maxX = std::numeric_limits<float>::lowest(), maxY = std::numeric_limits<float>::lowest(),
maxZ = std::numeric_limits<float>::lowest();
auto const overrideBBox = this->overrideBBoxSlot.Param<core::param::BoolParam>()->Value();
auto const overrideLBBox = this->overrideLBBoxSlot.Param<core::param::BoolParam>()->Value();
if ((overrideBBox || overrideLBBox) && (doX || doY || doZ)) {
size_t step;
for (size_t l = 0, max = inData.GetParticleListCount(); l < max; l++) {
if (rad < inData.AccessParticles(l).GetGlobalRadius()) rad = inData.AccessParticles(l).GetGlobalRadius();
if (inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexDataType() ==
megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_FLOAT_XYZ ||
inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexDataType() ==
megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_FLOAT_XYZR) {
posFromSomethingFunc getPoint;
float localMinX = std::numeric_limits<float>::max(), localMinY = std::numeric_limits<float>::max(),
localMinZ = std::numeric_limits<float>::max();
float localMaxX = std::numeric_limits<float>::lowest(),
localMaxY = std::numeric_limits<float>::lowest(),
localMaxZ = std::numeric_limits<float>::lowest();
switch (inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexDataType()) {
case megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_FLOAT_XYZ:
getPoint = posFromXYZ;
break;
case megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_FLOAT_XYZR:
getPoint = posFromXYZR;
break;
}
size_t maxP = inData.AccessParticles(static_cast<unsigned int>(l)).GetCount();
if (samples == 0) {
step = 1;
} else {
step = maxP / samples;
}
void* vertPtr = const_cast<void*>(inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexData());
size_t stride = inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexDataStride();
// gief openmp 3.1
//#pragma omp parallel for reduction(min: minX, max: maxX)
for (size_t p = 0; p < maxP; p += step) {
vislib::math::ShallowPoint<float, 3> sp = getPoint(vertPtr, stride, p);
if (sp.GetX() < minX) {
minX = sp.GetX();
}
if (sp.GetX() > maxX) {
maxX = sp.GetX();
}
if (sp.GetY() < minY) {
minY = sp.GetY();
}
if (sp.GetY() > maxY) {
maxY = sp.GetY();
}
if (sp.GetZ() < minZ) {
minZ = sp.GetZ();
}
if (sp.GetZ() > maxZ) {
maxZ = sp.GetZ();
}
// local bbox
if (sp.GetX() < localMinX) {
localMinX = sp.GetX();
}
if (sp.GetX() > localMaxX) {
localMaxX = sp.GetX();
}
if (sp.GetY() < localMinY) {
localMinY = sp.GetY();
}
if (sp.GetY() > localMaxY) {
localMaxY = sp.GetY();
}
if (sp.GetZ() < localMinZ) {
localMinZ = sp.GetZ();
}
if (sp.GetZ() > localMaxZ) {
localMaxZ = sp.GetZ();
}
}
if (overrideLBBox) {
outData.AccessParticles(l).SetBBox(
vislib::math::Cuboid<float>(localMinX, localMinY, localMinZ, localMaxX, localMaxY, localMaxZ));
}
} else {
switch (inData.AccessParticles(static_cast<unsigned int>(l)).GetVertexDataType()) {
case megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_SHORT_XYZ:
// getPoint = posFromXYZ_SHORT;
megamol::core::utility::log::Log::DefaultLog.WriteError(
"OverrideParticleBBox does not support re-computation of short coordinates");
break;
case megamol::core::moldyn::MultiParticleDataCall::Particles::VERTDATA_NONE:
megamol::core::utility::log::Log::DefaultLog.WriteInfo("OverrideParticleBBox: skipping empty vertex data");
break;
}
}
}
}
inData.SetUnlocker(nullptr, false); // keep original data locked
// original data will be unlocked through outData
if (this->overrideBBoxSlot.Param<core::param::BoolParam>()->Value()) {
const vislib::math::Vector<float, 3>& l = this->bboxMinSlot.Param<core::param::Vector3fParam>()->Value();
const vislib::math::Vector<float, 3>& u = this->bboxMaxSlot.Param<core::param::Vector3fParam>()->Value();
outData.AccessBoundingBoxes().SetObjectSpaceBBox(doX ? minX : l.X(), doY ? minY : l.Y(), doZ ? minZ : l.Z(),
doX ? maxX : u.X(), doY ? maxY : u.Y(), doZ ? maxZ : u.Z());
outData.AccessBoundingBoxes().SetObjectSpaceClipBox(doX ? minX - rad : l.X(), doY ? minY - rad : l.Y(),
doZ ? minZ - rad : l.Z(), doX ? maxX - rad : u.X(), doY ? maxY - rad : u.Y(), doZ ? maxZ - rad : u.Z());
outData.AccessBoundingBoxes().MakeScaledWorld(1.0f);
if (this->autocomputeSlot.IsDirty()) {
megamol::core::utility::log::Log::DefaultLog.WriteInfo("[OverrideParticleBBox] BBox: %f %f %f %f %f %f", doX ? minX : l.X(),
doY ? minY : l.Y(), doZ ? minZ : l.Z(), doX ? maxX : u.X(), doY ? maxY : u.Y(), doZ ? maxZ : u.Z());
this->autocomputeSlot.ResetDirty();
}
}
return true;
}
| 48.864865
| 136
| 0.604772
|
azuki-monster
|
78c01f013e7bb16547c22020cf96ab5312c76125
| 1,165
|
cpp
|
C++
|
Contest/200911/20009.cpp
|
wzl19371/OI-LIfe
|
f7f54542d1369b5e4047fcbb2e26c1c64d22ee26
|
[
"MIT"
] | 1
|
2020-10-05T02:07:52.000Z
|
2020-10-05T02:07:52.000Z
|
Contest/200911/20009.cpp
|
wzl19371/OI-LIfe
|
f7f54542d1369b5e4047fcbb2e26c1c64d22ee26
|
[
"MIT"
] | null | null | null |
Contest/200911/20009.cpp
|
wzl19371/OI-LIfe
|
f7f54542d1369b5e4047fcbb2e26c1c64d22ee26
|
[
"MIT"
] | null | null | null |
#include <cstdio>
#include <algorithm>
#include <queue>
#include <set>
using namespace std;
const int maxn=1007;
const int MAX=1.1e9;
int n,a[maxn],b[maxn],ans[maxn],cnt;
bool v[maxn];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=n;i++) scanf("%d",&b[i]);
sort(b+1,b+1+n);
for(int i=1;i<=n;i++){
int minn=MAX,mi;
for(int j=1;j<=n;j++){
if(b[j]>a[i]&&b[j]<minn&&!v[j]){
minn=b[j];
mi=j;
}
}
if(minn==MAX){
for(int j=1;j<=n;j++){
if(!v[j]){
ans[i]=b[j];
v[j]=true;
break;
}
}
}else{
ans[i]=minn;
v[mi]=true;
}
}
for(int i=1;i<=n;i++){
for(int j=i+1;j<=n;j++){
if(ans[i]>a[i]&&ans[j]>a[j]&&ans[i]>a[j]&&ans[j]>a[i]&&ans[i]<ans[j]) swap(ans[i],ans[j]);
else if(((ans[i]>a[i])^(ans[j]>a[j]))&&((ans[i]>a[j])^(ans[j]>a[i]))&&ans[i]<ans[j]) swap(ans[i],ans[j]);
else if((ans[i]<=a[i]&&ans[j]<=a[j])&&(ans[i]<=a[j]&&ans[j]<=a[i])&&ans[i]<ans[j]) swap(ans[i],ans[j]);
// for(int i=1;i<=n;i++) printf("%d ",ans[i]);
// puts("");
}
}
for(int i=1;i<=n;i++) printf("%d ",ans[i]);
puts("");
return 0;
}
| 23.77551
| 109
| 0.461803
|
wzl19371
|
78c1089cb8bbbd3fb0fa90b1c11af01e7aaef393
| 230
|
cpp
|
C++
|
(1)Beginner/1020/c++/1020.cpp
|
G4DavidAlmeida/mySolutionsUriOnline
|
47e427e3205124da00a8a44fb9900086d85c30ec
|
[
"MIT"
] | null | null | null |
(1)Beginner/1020/c++/1020.cpp
|
G4DavidAlmeida/mySolutionsUriOnline
|
47e427e3205124da00a8a44fb9900086d85c30ec
|
[
"MIT"
] | null | null | null |
(1)Beginner/1020/c++/1020.cpp
|
G4DavidAlmeida/mySolutionsUriOnline
|
47e427e3205124da00a8a44fb9900086d85c30ec
|
[
"MIT"
] | null | null | null |
#include<iostream>
using namespace std;
int main(){
int x;
cin >> x;
cout << x / 365 << " ano(s)" << endl; x = x % 365;
cout << x / 30 << " mes(es)" << endl; x = x % 30;
cout << x << " dia(s)" << endl;
return 0;
}
| 14.375
| 51
| 0.469565
|
G4DavidAlmeida
|
78c2d9c9df41d8acb647225b53a67f6eb35a45f6
| 2,281
|
cc
|
C++
|
llvm_codegen/generate_expression.cc
|
maciekgajewski/cougar
|
038a0c6f901928946b03e203c2154ca02bce9524
|
[
"Apache-2.0"
] | null | null | null |
llvm_codegen/generate_expression.cc
|
maciekgajewski/cougar
|
038a0c6f901928946b03e203c2154ca02bce9524
|
[
"Apache-2.0"
] | 4
|
2021-05-02T08:27:25.000Z
|
2021-05-15T08:37:26.000Z
|
llvm_codegen/generate_expression.cc
|
maciekgajewski/cougar
|
038a0c6f901928946b03e203c2154ca02bce9524
|
[
"Apache-2.0"
] | 1
|
2021-04-24T20:20:58.000Z
|
2021-04-24T20:20:58.000Z
|
#include "code_generator.hh"
#include "ast/expression.hh"
#include "meta/type_info.hh"
#include <llvm/IR/GlobalVariable.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/Type.h>
#include <llvm/IR/Value.h>
namespace Cougar::LlvmCodeGenerator {
llvm::Value *CodeGenerator::generateExpression(Ast::Expression *e) {
return e->visit([this](auto &data) { return generateExpression(data); });
}
llvm::Value *CodeGenerator::generateExpression(Ast::ExStringLiteral &strLit) {
llvm::ArrayType *arrayType = llvm::ArrayType::get(
llvm::Type::getInt8Ty(*mContext), strLit.content.size() + 1);
llvm::GlobalVariable *strConst = new llvm::GlobalVariable(
*mModule, // module
arrayType, // type
true, // is const
llvm::GlobalValue::LinkageTypes::PrivateLinkage, // linkage
nullptr, // initializer
llvm::Twine("str_const") // name
);
llvm::Constant *c =
llvm::ConstantDataArray::getString(*mContext, strLit.content);
strConst->setInitializer(c);
strConst->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
// generate "GEP" (getelementpopinter) instruction
return mBuilder->CreateConstGEP2_64(arrayType, strConst, 0, 0);
}
llvm::Value *CodeGenerator::generateExpression(Ast::ExNumberLiteral &) {
throw std::logic_error("Unable to generate code for number literal");
}
llvm::Value *CodeGenerator::generateExpression(Ast::ExImplicitCast &) {
throw std::logic_error("Unable to generate code for implicit cast");
}
llvm::Value *CodeGenerator::generateExpression(Ast::ExConstant &c) {
assert(c.targetType);
llvm::Type *type = toLlvm(c.targetType);
if (type->isIntegerTy()) {
return llvm::ConstantInt::get(type, std::uint64_t(c.value),
type->isSingleValueType());
} else if (type->isFloatingPointTy()) {
return llvm::ConstantFP::get(*mContext, llvm::APFloat(c.value));
} else {
throw std::logic_error(
fmt::format("Unable to generate code for constant of type '{}'",
c.targetType->prettyName()));
}
}
} // namespace Cougar::LlvmCodeGenerator
| 34.560606
| 78
| 0.633932
|
maciekgajewski
|
78c3ae72d634ee5a60dfb15364a02c654b288887
| 5,681
|
hpp
|
C++
|
include/opentxs/core/contract/UnitDefinition.hpp
|
nopdotcom/opentxs
|
140428ba8f1bd4c09654ebf0a1c1725f396efa8b
|
[
"MIT"
] | null | null | null |
include/opentxs/core/contract/UnitDefinition.hpp
|
nopdotcom/opentxs
|
140428ba8f1bd4c09654ebf0a1c1725f396efa8b
|
[
"MIT"
] | null | null | null |
include/opentxs/core/contract/UnitDefinition.hpp
|
nopdotcom/opentxs
|
140428ba8f1bd4c09654ebf0a1c1725f396efa8b
|
[
"MIT"
] | null | null | null |
// Copyright (c) 2018 The Open-Transactions developers
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef OPENTXS_CORE_CONTRACT_UNITDEFINITION_HPP
#define OPENTXS_CORE_CONTRACT_UNITDEFINITION_HPP
#include "opentxs/Forward.hpp"
#include "opentxs/core/contract/Signable.hpp"
#include "opentxs/core/Contract.hpp"
#include "opentxs/core/Nym.hpp"
#include "opentxs/core/String.hpp"
#include "opentxs/Proto.hpp"
#include <cstdint>
#include <string>
namespace opentxs
{
class UnitDefinition : public Signable
{
private:
typedef Signable ot_super;
std::string primary_unit_name_;
std::string short_name_;
proto::UnitDefinition contract(const Lock& lock) const;
OTIdentifier GetID(const Lock& lock) const override;
bool verify_signature(const Lock& lock, const proto::Signature& signature)
const override;
protected:
const api::Wallet& wallet_;
std::string primary_unit_symbol_;
static OTIdentifier GetID(const proto::UnitDefinition& contract);
virtual proto::UnitDefinition IDVersion(const Lock& lock) const;
virtual proto::UnitDefinition SigVersion(const Lock& lock) const;
bool validate(const Lock& lock) const override;
bool update_signature(const Lock& lock) override;
UnitDefinition(
const api::Wallet& wallet,
const ConstNym& nym,
const proto::UnitDefinition serialized);
UnitDefinition(
const api::Wallet& wallet,
const ConstNym& nym,
const std::string& shortname,
const std::string& name,
const std::string& symbol,
const std::string& terms);
public:
EXPORT static UnitDefinition* Create(
const api::Wallet& wallet,
const ConstNym& nym,
const std::string& shortname,
const std::string& name,
const std::string& symbol,
const std::string& terms,
const std::string& tla,
const std::uint32_t& power,
const std::string& fraction);
EXPORT static UnitDefinition* Create(
const api::Wallet& wallet,
const ConstNym& nym,
const std::string& shortname,
const std::string& name,
const std::string& symbol,
const std::string& terms,
const std::uint64_t weight);
EXPORT static UnitDefinition* Create(
const api::Wallet& wallet,
const ConstNym& nym,
const std::string& shortname,
const std::string& name,
const std::string& symbol,
const std::string& terms);
EXPORT static UnitDefinition* Factory(
const api::Wallet& wallet,
const ConstNym& nym,
const proto::UnitDefinition& serialized);
// Some instrument definitions keep a list of "user" accounts (the
// complete set of
// that type.)
// This is called when the user creates a new asset account, in order to add
// it to that list.
// (Currently only operational for "shares", not "currencies", since it's
// used exclusively
// for the payment of dividends.)
// adds the account to the list. (When account is created.)
EXPORT bool AddAccountRecord(
const std::string& dataFolder,
const Account& theAccount) const;
// removes the account from the list. (When account is deleted.)
EXPORT bool EraseAccountRecord(
const std::string& dataFolder,
const Identifier& theAcctID) const;
EXPORT bool VisitAccountRecords(
const std::string& dataFolder,
AccountVisitor& visitor) const;
EXPORT static std::string formatLongAmount(
std::int64_t lValue,
std::int32_t nFactor = 100,
std::int32_t nPower = 2,
const char* szCurrencySymbol = "",
const char* szThousandSeparator = ",",
const char* szDecimalPoint = ".");
EXPORT static bool ParseFormatted(
std::int64_t& lResult,
const std::string& str_input,
std::int32_t nFactor = 100,
std::int32_t nPower = 2,
const char* szThousandSeparator = ",",
const char* szDecimalPoint = ".");
EXPORT const std::string& GetCurrencyName() const
{
return primary_unit_name_;
}
EXPORT const std::string& GetCurrencySymbol() const
{
return primary_unit_symbol_;
}
EXPORT virtual bool DisplayStatistics(String& strContents) const;
EXPORT proto::UnitDefinition Contract() const;
EXPORT bool FormatAmountLocale(
std::int64_t amount,
std::string& str_output,
const std::string& str_thousand,
const std::string& str_decimal) const;
EXPORT bool FormatAmountWithoutSymbolLocale(
std::int64_t amount,
std::string& str_output,
const std::string& str_thousand,
const std::string& str_decimal) const;
EXPORT bool StringToAmountLocale(
std::int64_t& amount,
const std::string& str_input,
const std::string& str_thousand,
const std::string& str_decimal) const;
EXPORT OTData Serialize() const override;
EXPORT std::string Name() const override { return short_name_; }
EXPORT proto::UnitDefinition PublicContract() const;
EXPORT virtual std::int32_t DecimalPower() const { return 0; }
EXPORT virtual std::string FractionalUnitName() const { return ""; }
EXPORT virtual std::string TLA() const { return short_name_; }
EXPORT virtual proto::UnitType Type() const = 0;
EXPORT void SetAlias(const std::string& alias) override;
EXPORT virtual ~UnitDefinition() = default;
};
} // namespace opentxs
#endif
| 33.417647
| 80
| 0.6696
|
nopdotcom
|
78c6abe1bd327b96f70d2dbc8fa355c23249fb48
| 8,536
|
cc
|
C++
|
TrkBase/TrkExpectedTrk.cc
|
brownd1978/FastSim
|
05f590d72d8e7f71856fd833114a38b84fc7fd48
|
[
"Apache-2.0"
] | null | null | null |
TrkBase/TrkExpectedTrk.cc
|
brownd1978/FastSim
|
05f590d72d8e7f71856fd833114a38b84fc7fd48
|
[
"Apache-2.0"
] | null | null | null |
TrkBase/TrkExpectedTrk.cc
|
brownd1978/FastSim
|
05f590d72d8e7f71856fd833114a38b84fc7fd48
|
[
"Apache-2.0"
] | null | null | null |
//--------------------------------------------------------------------------
// File and Version Information:
// $Id: TrkExpectedTrk.cc,v 1.8 2004/09/10 18:00:17 bartoldu Exp $
//
// Description:
// Class TrkExpectedTrack. Stores lists of expected hits for a given
// track in the Trk.
//
// Environment:
// Software developed for Babar experiment @ Slac B-factory.
//
// Author List:
// Eric A Charles
//
//------------------------------------------------------------------------
//----------------
// BaBar header
//----------------
#include "BaBar/BaBar.hh"
//-----------------------
// This Class's Header --
//-----------------------
#include "TrkBase/TrkExpectedTrk.hh"
//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "BbrStdUtils/BbrPairUtils.hh"
#include "TrkBase/TrkFitTypeKey.hh"
#include "TrkBase/TrkExpectedHotSet.hh"
#include "TrkBase/TrkExpectedHot.hh"
#include "TrkBase/TrkExpectedMap.hh"
#include "TrkBase/TrkHitOnTrk.hh"
#include "TrkBase/TrkRecoTrk.hh"
#include "TrkBase/TrkRep.hh"
#include "TrkBase/TrkTypeUtil.hh"
#include "TrkBase/TrkFundHit.hh"
#include "TrkBase/TrkExpectedHotFactory.hh"
using std::ostream;
//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------
// -----------------------------------------------
// -- Static Data & Function Member Definitions --
// -----------------------------------------------
// ----------------------------------------
// -- Public Function Member Definitions --
// ----------------------------------------
//----------------
// Constructors --
//----------------
TrkExpectedTrk::TrkExpectedTrk ( const TrkRecoTrk* trk,
const PdtPid::PidType pidType,
const GTrack* gTrk,
TrkExpectedMap* exMap)
:_parentMap(exMap),
_refRep(TrkTypeUtil::getRep(*trk,pidType)),
_gTrk(gTrk)
{
}
TrkExpectedTrk::~TrkExpectedTrk( )
{
// This class owns expected Hots.
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
for (map_t::const_iterator itr=_exHotTable.begin();itr!=_exHotTable.end();++itr) {
delete itr->second;
}
}
const TrkRecoTrk*
TrkExpectedTrk::track() const
{
return _refRep == 0 ? 0 : _refRep->parentTrack();
}
const TrkExpectedHotSet*
TrkExpectedTrk::exHotSet( const TrkDetElemId& elemId) const
{
typedef std::map<TrkDetElemId,TrkExpectedHotSet*> map_t;
map_t::const_iterator i = _exHotTable.find(elemId);
return (i==_exHotTable.end()?0:i->second);
}
const TrkExpectedHotSet*
TrkExpectedTrk::exHotSet( const TrkHitOnTrk* hot ) const
{
if ( hot == 0 ) return 0;
const TrkDetElemId id = hot->hit()->elemId();
return exHotSet( id );
}
const TrkExpectedHotSet*
TrkExpectedTrk::exHotSet( const TrkFundHit* hit ) const
{
if ( hit == 0 ) return 0;
const TrkDetElemId id = hit->elemId();
return exHotSet( id );
}
const TrkExpectedHot*
TrkExpectedTrk::exHot( const TrkDetElemId& elemId,
const TrkFitTypeKey key ) const
{
const TrkExpectedHotSet* hotSet = exHotSet(elemId);
return hotSet != 0 ? hotSet->exHot( key ): 0;
}
const TrkExpectedHot*
TrkExpectedTrk::exHot( const TrkHitOnTrk* hot ) const
{
const TrkExpectedHotSet* hotSet = exHotSet(hot);
const TrkFitTypeKey key =
_parentMap == 0 ? TrkFitTypeKey() : _parentMap->getFitType( hot );
return hotSet != 0 ? hotSet->exHot( key ): 0;
}
const TrkExpectedHot*
TrkExpectedTrk::exHot( const TrkFundHit* hit,
const TrkFitTypeKey key ) const
{
const TrkExpectedHotSet* hotSet = exHotSet(hit);
return hotSet != 0 ? hotSet->exHot( key ) : 0;
}
void
TrkExpectedTrk::fillExHotSets( std::vector<TrkExpectedHotSet*>& hotSets ) const
{
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
typedef std::back_insert_iterator<std::vector<TrkExpectedHotSet*> > insert_t;
std::transform(_exHotTable.begin(),_exHotTable.end(), insert_t(hotSets), babar::Pair::select2nd<map_t::value_type>());
}
void
TrkExpectedTrk::fillExHots( const TrkFitTypeKey& key,
std::vector<TrkExpectedHot*>& hots ) const
{
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
for (map_t::const_iterator itr=_exHotTable.begin();itr!=_exHotTable.end();++itr) {
TrkExpectedHotSet* set = itr->second;
TrkExpectedHot* aHot = const_cast<TrkExpectedHot*>(set->exHot(key));
if ( aHot == 0 ) continue;
hots.push_back(aHot);
}
}
void
TrkExpectedTrk::printFit( const TrkFitTypeKey& key,
ostream& os ) const
{
const TrkRecoTrk* refTrack = track();
if ( refTrack ) refTrack->print(os);
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
for (map_t::const_iterator itr=_exHotTable.begin();itr!=_exHotTable.end();++itr) {
TrkExpectedHotSet* exHots = itr->second;
exHots->printFit(key,os);
}
}
bool
TrkExpectedTrk::addExHotSet( const TrkDetElemId& id,
TrkExpectedHotSet* val )
{
_exHotTable.insert(std::make_pair(id,val));
val->setExTrk(this);
return true;
}
// -----------------------------------------
// -- Private Function Member Definitions --
// -----------------------------------------
bool
TrkExpectedTrk::parseHotSetFromMap( TrkExpectedHotSet* hotSet,
const TrkFitTypeKey& key ){
if ( hotSet == 0 || _parentMap == 0 ) return false;
// get the other hots associated with same fund hit
std::vector<TrkHitOnTrk*> hots;
hotSet->getHots(hots);
// loop on the hots
for ( int i(0); i < hots.size(); ++i ) {
const TrkHitOnTrk* hot = hots[i];
// get the fit type and see if it is in the map
TrkFitTypeKey fitTypeKey = _parentMap->getFitType( hot );
if ( ! ( fitTypeKey == key ) ) continue;
// see if we already have exHot of this type
//const TrkExpectedHot* exHot =
_parentMap->exHotFactory()->parseExHotIntoSet( hot, fitTypeKey,*hotSet, false );
// put in the the rep list, even if allready in,
// because that is how me test the number of overlaps
_reps.push_back( hot->getParentRep() );
}
return true;
}
bool
TrkExpectedTrk::parseHotSetFromMap( TrkExpectedHotSet* hotSet){
if ( hotSet == 0 || _parentMap == 0 ) return false;
// get the other hots associated with same fund hit
std::vector<TrkHitOnTrk*> hots;
hotSet->getHots(hots);
// loop on the hots
for ( int i(0); i < hots.size(); ++i ) {
const TrkHitOnTrk* hot = hots[i];
// get the fit type and see if it is in the map
TrkFitTypeKey fitTypeKey = _parentMap->getFitType( hot );
if ( fitTypeKey.value() < 0 ) continue;
// see if we already have exHot of this type
//const TrkExpectedHot* exHot =
_parentMap->exHotFactory()->parseExHotIntoSet( hot, fitTypeKey,*hotSet, false );
// put in the the rep list, even if allready in,
// because that is how me test the number of overlaps
_reps.push_back( hot->getParentRep() );
}
return true;
}
bool TrkExpectedTrk::parseHotFromMap( const TrkHitOnTrk* hot,
const bool fillGaps )
{
// check parent map and fit type
if ( _parentMap == 0 || hot == 0 ) return false;
TrkFitTypeKey fitTypeKey = _parentMap->getFitType( hot );
if ( fitTypeKey.value() < 0 ) return false;
const TrkExpectedHotSet* hotSet = exHotSet(hot);
TrkExpectedHotSet* theSet(0);
if ( hotSet == 0 ) {
if ( !fillGaps ) return false;
const TrkDetElemId id = hot->hit()->elemId();
TrkExpectedHotSet* theSet =
new TrkExpectedHotSet( id, TrkFitTypeKey::currentKey() );
addExHotSet( id, theSet );
} else {
theSet = (TrkExpectedHotSet*)hotSet;
}
//const TrkExpectedHot* exHot =
_parentMap->exHotFactory()->parseExHotIntoSet( hot, fitTypeKey,*theSet, false);
_reps.push_back( hot->getParentRep() );
return true;
}
bool
TrkExpectedTrk::parseHotsFromMap( const TrkFitTypeKey& key )
{
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
for (map_t::const_iterator itr=_exHotTable.begin();itr!=_exHotTable.end();++itr) {
if ( !parseHotSetFromMap( itr->second, key ) ) continue;
}
return true;
}
bool
TrkExpectedTrk::parseHotsFromMap( )
{
typedef std::map<TrkDetElemId, TrkExpectedHotSet*> map_t;
for (map_t::const_iterator itr=_exHotTable.begin();itr!=_exHotTable.end();++itr) {
if ( !parseHotSetFromMap( itr->second ) ) continue;
}
return true;
}
| 30.162544
| 120
| 0.618088
|
brownd1978
|
78ca57bdd81971745bbde289c7b9e01783ff7396
| 1,469
|
cpp
|
C++
|
user/gui/windowserver/src/Log.cpp
|
tristanseifert/kush-os
|
1ffd595aae8f3dc880e798eff72365b8b6c631f0
|
[
"0BSD"
] | 4
|
2021-06-22T20:52:30.000Z
|
2022-02-04T00:19:44.000Z
|
user/gui/windowserver/src/Log.cpp
|
tristanseifert/kush-os
|
1ffd595aae8f3dc880e798eff72365b8b6c631f0
|
[
"0BSD"
] | null | null | null |
user/gui/windowserver/src/Log.cpp
|
tristanseifert/kush-os
|
1ffd595aae8f3dc880e798eff72365b8b6c631f0
|
[
"0BSD"
] | null | null | null |
#include "Log.h"
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
extern const char *gLogTag;
#ifdef NDEBUG
static bool gLogTraceEnabled = false;
#else
static bool gLogTraceEnabled = true;
#endif
/// Outputs a message if trace logging is enabled
void Trace(const char * _Nonnull str, ...) {
if(!gLogTraceEnabled) return;
fprintf(stdout, "\e[34m[%s] ", gLogTag);
va_list va;
va_start(va, str);
vfprintf(stdout, str, va);
va_end(va);
fputs("\e[0m\n", stdout);
}
/**
* Logs a success message.
*/
void Success(const char *str, ...) {
fprintf(stderr, "\e[32m[%s] ", gLogTag);
va_list va;
va_start(va, str);
vfprintf(stderr, str, va);
va_end(va);
fputs("\e[0m\n", stderr);
}
/**
* Logs an informational message.
*/
void Info(const char *str, ...) {
fprintf(stderr, "[%s] ", gLogTag);
va_list va;
va_start(va, str);
vfprintf(stderr, str, va);
va_end(va);
fputs("\n", stderr);
}
/**
* Logs a warning message.
*/
void Warn(const char *str, ...) {
fprintf(stderr, "\e[33m[%s] ", gLogTag);
va_list va;
va_start(va, str);
vfprintf(stderr, str, va);
va_end(va);
fputs("\e[0m\n", stderr);
}
/**
* Logs an error and terminates the task.
*/
void Abort(const char *str, ...) {
fprintf(stderr, "\e[31m[%s] ", gLogTag);
va_list va;
va_start(va, str);
vfprintf(stderr, str, va);
va_end(va);
fputs("\e[0m\n", stderr);
_Exit(-69);
}
| 18.135802
| 49
| 0.59224
|
tristanseifert
|
78ca5b24eec67d81b4cc663faa393e01be8e64ff
| 1,014
|
cpp
|
C++
|
heap/23 Merge k Sorted Lists.cpp
|
CoderQuinnYoung/leetcode
|
6ea15c68124b16824bab9ed2e0e5a40c72eb3db1
|
[
"BSD-3-Clause"
] | null | null | null |
heap/23 Merge k Sorted Lists.cpp
|
CoderQuinnYoung/leetcode
|
6ea15c68124b16824bab9ed2e0e5a40c72eb3db1
|
[
"BSD-3-Clause"
] | null | null | null |
heap/23 Merge k Sorted Lists.cpp
|
CoderQuinnYoung/leetcode
|
6ea15c68124b16824bab9ed2e0e5a40c72eb3db1
|
[
"BSD-3-Clause"
] | null | null | null |
//
// 23 Merge k Sorted Lists.cpp
// Leetcode
//
// Created by Quinn on 2020/9/12.
// Copyright © 2020 Quinn. All rights reserved.
//
#include "ListNode.h"
#include <queue>
using namespace std;
class Solution {
public:
struct Cmp {
bool operator() (ListNode *a, ListNode *b) const {
return a->val > b->val;
}
};
ListNode* mergeKLists(vector<ListNode*>& lists) {
priority_queue<ListNode *, vector<ListNode *>, Cmp> heap;
ListNode *dummy = new ListNode(-1);
ListNode *tail = dummy;
for (auto l : lists) {
if(l) heap.push(l);
}
while (!heap.empty()) {
auto top = heap.top();
heap.pop();
if (top) {
tail->next = top;
tail = tail->next;
if (top->next) {
heap.push(top->next);
}
}
}
return dummy->next;
}
};
| 21.574468
| 65
| 0.453649
|
CoderQuinnYoung
|
78d083d1338810b6dddb9e19bd00cd4ee23b4cbd
| 3,034
|
cpp
|
C++
|
src/ATmega328P/L3G4200D/TWI.cpp
|
smurilogs/EmbeddedSystems-ATmega328P-ArduinoPlatform-InterfacingLibraries
|
30795f46112ab5b56a8244b198f0193afb8755ba
|
[
"MIT"
] | null | null | null |
src/ATmega328P/L3G4200D/TWI.cpp
|
smurilogs/EmbeddedSystems-ATmega328P-ArduinoPlatform-InterfacingLibraries
|
30795f46112ab5b56a8244b198f0193afb8755ba
|
[
"MIT"
] | null | null | null |
src/ATmega328P/L3G4200D/TWI.cpp
|
smurilogs/EmbeddedSystems-ATmega328P-ArduinoPlatform-InterfacingLibraries
|
30795f46112ab5b56a8244b198f0193afb8755ba
|
[
"MIT"
] | null | null | null |
#include "TWI.h"
TWI::TWI(void)
{
}
void TWI::initAsMaster(void)
{
// 400kHz of SCL from 16MHz of fSYS
TWSR &= ~(1 << 1) & ~(1 << 0); // Sets prescaler as 1
TWBR = 12; // Calc reference value for SCL
//(IF YOU'RE GONNA USE INTERRUPT)
//TWCR != (1 << 0); // Enables the TWI module interrupt
// Enables TWI module
TWCR |= (1 << 2);
}
void TWI::initAsSlave(void)
{
// to do
}
uint8_t TWI::start(uint8_t aDevAddr)
{
// reset TWI control register
TWCR = 0;
// transmit START condition
TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
// wait for end of transmission
while(!(TWCR & (1 << TWINT)));
// check if the start condition was successfully transmitted
if((TWSR & 0xF8) != TW_START){ return 1; }
// load slave address into data register
TWDR = aDevAddr;
// start transmission of address
TWCR = (1 << TWINT) | (1 << TWEN);
// wait for end of transmission
while(!(TWCR & (1 << TWINT)) );
// check if the device has acknowledged the READ / WRITE mode
uint8_t twst = TW_STATUS & 0xF8;
if ((twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK))
return 1;
return 0;
}
uint8_t TWI::write(uint8_t aData)
{
// load data into data register
TWDR = aData;
// start transmission of data
TWCR = (1 << TWINT) | (1 << TWEN);
// wait for end of transmission
while(!(TWCR & (1 << TWINT)));
if((TWSR & 0xF8) != TW_MT_DATA_ACK )
return 1;
return 0;
}
uint8_t TWI::readACK(void)
{
// start TWI module and acknowledge data after reception
TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
// wait for end of transmission
while(!(TWCR & (1 << TWINT)));
// return received data from TWDR
return TWDR;
}
uint8_t TWI::readNACK(void)
{
// start receiving without acknowledging reception
TWCR = (1 << TWINT) | (1 << TWEN);
// wait for end of transmission
while(!(TWCR & (1 << TWINT)));
// return received data from TWDR
return TWDR;
}
void TWI::stop(void)
{
// transmit STOP condition
TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
}
uint8_t TWI::addW(uint8_t aDevAddr)
{
uint8_t data;
data |= (aDevAddr << 1) | (0 << 0);
return data;
}
uint8_t TWI::addR(uint8_t aAddr)
{
uint8_t data;
data |= (aAddr << 1) | (1 << 0);
return data;
}
void TWI::writeRegister(uint8_t aDevAddr, uint8_t aRegAddr, uint8_t aData)
{
TWI::start(TWI::addW(aDevAddr)); // start transmission to device
TWI::write(aRegAddr); // send register address
TWI::write(aData); // send value to write
TWI::stop(); // end transmission
}
uint8_t TWI::readRegister(uint8_t aDevAddr, uint8_t aRegAddr)
{
uint8_t v;
TWI::start(TWI::addW(aDevAddr));
TWI::write(aRegAddr); // register to read
TWI::start(TWI::addR(aDevAddr));
v = TWI::readNACK();
TWI::stop();
return v;
}
| 21.069444
| 74
| 0.567238
|
smurilogs
|
78d19cfafd2eba97716670f93ba999f2671d77d8
| 8,865
|
cc
|
C++
|
agent/php7/utils/yaml_reader.cc
|
yuesicheng/openrasp
|
60d772184887dcbec595ba7011b5b807ff652fba
|
[
"Apache-2.0"
] | 1
|
2020-05-29T13:30:02.000Z
|
2020-05-29T13:30:02.000Z
|
agent/php7/utils/yaml_reader.cc
|
yuesicheng/openrasp
|
60d772184887dcbec595ba7011b5b807ff652fba
|
[
"Apache-2.0"
] | null | null | null |
agent/php7/utils/yaml_reader.cc
|
yuesicheng/openrasp
|
60d772184887dcbec595ba7011b5b807ff652fba
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright 2017-2018 Baidu Inc.
*
* 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 "yaml_reader.h"
#include <sstream>
#include "openrasp_log.h"
#include "openrasp_error.h"
namespace openrasp
{
YamlReader::YamlReader()
{
}
YamlReader::YamlReader(const std::string &yaml_str)
{
load(yaml_str);
}
void YamlReader::load(const std::string &content)
{
try
{
std::stringstream ss(content);
YAML::Parser parser(ss);
parser.GetNextDocument(doc);
}
catch (YAML::ParserException &e)
{
error = true;
std::ostringstream oss;
oss << "message: " << e.what();
error_msg = oss.str();
}
}
std::string YamlReader::fetch_string(const std::vector<std::string> &keys, const std::string &default_value,
const openrasp::validator::vstring::Base &validator)
{
try
{
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
if (node->Type() == YAML::NodeType::Scalar)
{
std::string rst;
*node >> rst;
std::string error_description = validator.check(rst);
if (!error_description.empty())
{
throw YAML::RepresentationException(node->GetMark(), error_description);
}
return rst;
}
else
{
throw YAML::RepresentationException(node->GetMark(), "type should be string");
}
}
catch (const YAML::KeyNotFound &e)
{
}
catch (const YAML::BadDereference &e)
{
}
catch (const YAML::Exception &e)
{
if (get_exception_report())
{
openrasp_error(LEVEL_WARNING, CONFIG_ERROR, _("%s, config \"%s\" use the default value \"%s\""),
e.what(), BaseReader::stringfy_keys(keys).c_str(), default_value.c_str());
}
}
return default_value;
}
int64_t YamlReader::fetch_int64(const std::vector<std::string> &keys, const int64_t &default_value,
const openrasp::validator::vint64::Base &validator)
{
try
{
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
if (node->Type() == YAML::NodeType::Scalar)
{
int64_t rst;
*node >> rst;
std::string error_description = validator.check(rst);
if (!error_description.empty())
{
throw YAML::RepresentationException(node->GetMark(), error_description);
}
return rst;
}
else
{
throw YAML::RepresentationException(node->GetMark(), "type should be number");
}
}
catch (const YAML::KeyNotFound &e)
{
}
catch (const YAML::BadDereference &e)
{
}
catch (const YAML::Exception &e)
{
if (get_exception_report())
{
openrasp_error(LEVEL_WARNING, CONFIG_ERROR, _("%s, config \"%s\" use the default value %" PRId64 " "),
e.what(), BaseReader::stringfy_keys(keys).c_str(), default_value);
}
}
return default_value;
}
bool YamlReader::fetch_bool(const std::vector<std::string> &keys, const bool &default_value)
{
try
{
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
if (node->Type() == YAML::NodeType::Scalar)
{
bool rst = false;
*node >> rst;
return rst;
}
else
{
throw YAML::RepresentationException(node->GetMark(), "type should be boolen");
}
}
catch (const YAML::KeyNotFound &e)
{
}
catch (const YAML::BadDereference &e)
{
}
catch (const YAML::Exception &e)
{
if (get_exception_report())
{
openrasp_error(LEVEL_WARNING, CONFIG_ERROR, _("%s, config \"%s\" use the default value %s"),
e.what(), BaseReader::stringfy_keys(keys).c_str(), default_value ? "true" : "false");
}
}
return default_value;
}
std::vector<std::string> YamlReader::fetch_object_keys(const std::vector<std::string> &keys)
{
try
{
std::vector<std::string> rst;
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
if (node->Type() == YAML::NodeType::Map)
{
for (YAML::Iterator it = node->begin(); it != node->end(); ++it)
{
std::string key;
it.first() >> key;
rst.push_back(key);
}
}
else if (node->Type() == YAML::NodeType::Null)
{
//skip
}
else
{
throw YAML::RepresentationException(node->GetMark(), "type should be map");
}
return rst;
}
catch (const YAML::KeyNotFound &e)
{
}
catch (const YAML::BadDereference &e)
{
}
catch (const YAML::Exception &e)
{
if (get_exception_report())
{
openrasp_error(LEVEL_WARNING, CONFIG_ERROR, _("%s, config \"%s\""),
e.what(), BaseReader::stringfy_keys(keys).c_str());
}
}
return {};
}
std::vector<std::string> YamlReader::fetch_strings(const std::vector<std::string> &keys, const std::vector<std::string> &default_value)
{
try
{
std::vector<std::string> rst = default_value;
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
if (node->Type() == YAML::NodeType::Sequence)
{
rst.clear();
for (YAML::Iterator it = node->begin(); it != node->end(); ++it)
{
std::string val;
*it >> val;
rst.push_back(val);
}
}
else
{
throw YAML::RepresentationException(node->GetMark(), "type should be sequence");
}
return rst;
}
catch (const YAML::KeyNotFound &e)
{
}
catch (const YAML::BadDereference &e)
{
}
catch (const YAML::Exception &e)
{
if (get_exception_report())
{
openrasp_error(LEVEL_WARNING, CONFIG_ERROR, _("%s, config \"%s\" use the default value"),
e.what(), BaseReader::stringfy_keys(keys).c_str());
}
}
return default_value;
}
std::string YamlReader::dump(const std::vector<std::string> &keys, bool pretty)
{
std::string result;
try
{
std::vector<std::string> rst;
const YAML::Node *node = &doc;
for (auto key : keys)
{
node = &(*node)[key];
}
YAML::Emitter emitter;
emitter << *node;
result = std::string(emitter.c_str());
return result;
}
catch (...)
{
}
return result;
}
std::string YamlReader::dump(bool pretty)
{
return dump({}, pretty);
}
std::string YamlReader::detect_unknown_config_key()
{
static const std::set<std::string> php_known_keys = {
"plugin.timeout.millis",
"plugin.maxstack",
"plugin.filter",
"log.maxburst",
"log.maxstack",
"log.maxbackup",
"syslog.enable",
"syslog.tag",
"syslog.url",
"syslog.facility",
"syslog.connection_timeout",
"syslog.read_timeout",
"syslog.reconnect_interval",
"block.status_code",
"block.redirect_url",
"block.content_json",
"block.content_xml",
"block.content_html",
"inject.urlprefix",
"inject.custom_headers",
"body.maxbytes",
"clientip.header",
"security.weak_passwords",
"lru.max_size",
"debug.level",
"hook.white",
"response.sampler_interval",
"response.sampler_burst",
"decompile.enable"};
std::vector<std::string> found_keys = fetch_object_keys({});
for (auto &key : found_keys)
{
auto found = php_known_keys.find(key);
if (found == php_known_keys.end())
{
return key;
}
}
return "";
}
} // namespace openrasp
| 26.701807
| 135
| 0.529611
|
yuesicheng
|
78d1ad92e7c48f297c8a95f2d836f390838ab959
| 12,013
|
cpp
|
C++
|
shared/source/command_stream/scratch_space_controller_xehp_and_later.cpp
|
mattcarter2017/compute-runtime
|
1f52802aac02c78c19d5493dd3a2402830bbe438
|
[
"Intel",
"MIT"
] | null | null | null |
shared/source/command_stream/scratch_space_controller_xehp_and_later.cpp
|
mattcarter2017/compute-runtime
|
1f52802aac02c78c19d5493dd3a2402830bbe438
|
[
"Intel",
"MIT"
] | null | null | null |
shared/source/command_stream/scratch_space_controller_xehp_and_later.cpp
|
mattcarter2017/compute-runtime
|
1f52802aac02c78c19d5493dd3a2402830bbe438
|
[
"Intel",
"MIT"
] | null | null | null |
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/command_stream/scratch_space_controller_xehp_and_later.h"
#include "shared/source/command_stream/command_stream_receiver.h"
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/execution_environment/execution_environment.h"
#include "shared/source/execution_environment/root_device_environment.h"
#include "shared/source/helpers/aligned_memory.h"
#include "shared/source/helpers/api_specific_config.h"
#include "shared/source/helpers/constants.h"
#include "shared/source/helpers/hw_helper.h"
#include "shared/source/memory_manager/graphics_allocation.h"
#include "shared/source/memory_manager/internal_allocation_storage.h"
#include "shared/source/memory_manager/memory_manager.h"
#include "shared/source/os_interface/os_context.h"
namespace NEO {
ScratchSpaceControllerXeHPAndLater::ScratchSpaceControllerXeHPAndLater(uint32_t rootDeviceIndex,
ExecutionEnvironment &environment,
InternalAllocationStorage &allocationStorage)
: ScratchSpaceController(rootDeviceIndex, environment, allocationStorage) {
auto &hwHelper = HwHelper::get(environment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);
singleSurfaceStateSize = hwHelper.getRenderSurfaceStateSize();
if (DebugManager.flags.EnablePrivateScratchSlot1.get() != -1) {
privateScratchSpaceSupported = !!DebugManager.flags.EnablePrivateScratchSlot1.get();
}
if (privateScratchSpaceSupported) {
ScratchSpaceControllerXeHPAndLater::stateSlotsCount *= 2;
}
}
void ScratchSpaceControllerXeHPAndLater::setNewSshPtr(void *newSsh, bool &cfeDirty, bool changeId) {
if (surfaceStateHeap != newSsh) {
surfaceStateHeap = static_cast<char *>(newSsh);
if (scratchAllocation == nullptr) {
cfeDirty = false;
} else {
if (changeId) {
slotId = 0;
}
programSurfaceState();
cfeDirty = true;
}
}
}
void ScratchSpaceControllerXeHPAndLater::setRequiredScratchSpace(void *sshBaseAddress,
uint32_t offset,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
setNewSshPtr(sshBaseAddress, vfeStateDirty, offset == 0 ? true : false);
bool scratchSurfaceDirty = false;
prepareScratchAllocation(requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, scratchSurfaceDirty, vfeStateDirty);
if (scratchSurfaceDirty) {
vfeStateDirty = true;
updateSlots = true;
programSurfaceState();
}
}
void ScratchSpaceControllerXeHPAndLater::programSurfaceState() {
if (updateSlots) {
slotId++;
}
UNRECOVERABLE_IF(slotId >= stateSlotsCount);
UNRECOVERABLE_IF(scratchAllocation == nullptr && privateScratchAllocation == nullptr);
void *surfaceStateForScratchAllocation = ptrOffset(static_cast<void *>(surfaceStateHeap), getOffsetToSurfaceState(slotId + sshOffset));
programSurfaceStateAtPtr(surfaceStateForScratchAllocation);
}
void ScratchSpaceControllerXeHPAndLater::programSurfaceStateAtPtr(void *surfaceStateForScratchAllocation) {
auto &hwHelper = HwHelper::get(executionEnvironment.rootDeviceEnvironments[rootDeviceIndex]->getHardwareInfo()->platform.eRenderCoreFamily);
uint64_t scratchAllocationAddress = 0u;
if (scratchAllocation) {
scratchAllocationAddress = scratchAllocation->getGpuAddress();
}
hwHelper.setRenderSurfaceStateForBuffer(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex],
surfaceStateForScratchAllocation, computeUnitsUsedForScratch, scratchAllocationAddress, 0,
perThreadScratchSize, nullptr, false, scratchType, false, true);
if (privateScratchSpaceSupported) {
void *surfaceStateForPrivateScratchAllocation = ptrOffset(surfaceStateForScratchAllocation, singleSurfaceStateSize);
uint64_t privateScratchAllocationAddress = 0u;
if (privateScratchAllocation) {
privateScratchAllocationAddress = privateScratchAllocation->getGpuAddress();
}
hwHelper.setRenderSurfaceStateForBuffer(*executionEnvironment.rootDeviceEnvironments[rootDeviceIndex],
surfaceStateForPrivateScratchAllocation, computeUnitsUsedForScratch,
privateScratchAllocationAddress, 0, perThreadPrivateScratchSize, nullptr, false,
scratchType, false, true);
}
}
uint64_t ScratchSpaceControllerXeHPAndLater::calculateNewGSH() {
return 0u;
}
uint64_t ScratchSpaceControllerXeHPAndLater::getScratchPatchAddress() {
uint64_t scratchAddress = 0u;
if (scratchAllocation || privateScratchAllocation) {
if (ApiSpecificConfig::getBindlessConfiguration()) {
scratchAddress = bindlessSS.surfaceStateOffset;
} else {
scratchAddress = static_cast<uint64_t>(getOffsetToSurfaceState(slotId + sshOffset));
}
}
return scratchAddress;
}
size_t ScratchSpaceControllerXeHPAndLater::getOffsetToSurfaceState(uint32_t requiredSlotCount) const {
auto offset = requiredSlotCount * singleSurfaceStateSize;
if (privateScratchSpaceSupported) {
offset *= 2;
}
return offset;
}
void ScratchSpaceControllerXeHPAndLater::reserveHeap(IndirectHeap::Type heapType, IndirectHeap *&indirectHeap) {
if (heapType == IndirectHeap::Type::SURFACE_STATE) {
indirectHeap->getSpace(getOffsetToSurfaceState(stateSlotsCount));
}
}
void ScratchSpaceControllerXeHPAndLater::programBindlessSurfaceStateForScratch(BindlessHeapsHelper *heapsHelper,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty,
NEO::CommandStreamReceiver *csr) {
bool scratchSurfaceDirty = false;
prepareScratchAllocation(requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, scratchSurfaceDirty, vfeStateDirty);
if (scratchSurfaceDirty) {
bindlessSS = heapsHelper->allocateSSInHeap(singleSurfaceStateSize * (privateScratchSpaceSupported ? 2 : 1), scratchAllocation, BindlessHeapsHelper::SCRATCH_SSH);
programSurfaceStateAtPtr(bindlessSS.ssPtr);
vfeStateDirty = true;
}
csr->makeResident(*bindlessSS.heapAllocation);
}
void ScratchSpaceControllerXeHPAndLater::prepareScratchAllocation(uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &scratchSurfaceDirty,
bool &vfeStateDirty) {
uint32_t requiredPerThreadScratchSizeAlignedUp = alignUp(requiredPerThreadScratchSize, 64);
size_t requiredScratchSizeInBytes = requiredPerThreadScratchSizeAlignedUp * computeUnitsUsedForScratch;
scratchSurfaceDirty = false;
auto multiTileCapable = osContext.getNumSupportedDevices() > 1;
if (scratchSizeBytes < requiredScratchSizeInBytes) {
if (scratchAllocation) {
scratchAllocation->updateTaskCount(currentTaskCount, osContext.getContextId());
csrAllocationStorage.storeAllocation(std::unique_ptr<GraphicsAllocation>(scratchAllocation), TEMPORARY_ALLOCATION);
}
scratchSurfaceDirty = true;
scratchSizeBytes = requiredScratchSizeInBytes;
perThreadScratchSize = requiredPerThreadScratchSizeAlignedUp;
AllocationProperties properties{this->rootDeviceIndex, true, scratchSizeBytes, AllocationType::SCRATCH_SURFACE, multiTileCapable, false, osContext.getDeviceBitfield()};
scratchAllocation = getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
}
if (privateScratchSpaceSupported) {
uint32_t requiredPerThreadPrivateScratchSizeAlignedUp = alignUp(requiredPerThreadPrivateScratchSize, 64);
size_t requiredPrivateScratchSizeInBytes = requiredPerThreadPrivateScratchSizeAlignedUp * computeUnitsUsedForScratch;
if (privateScratchSizeBytes < requiredPrivateScratchSizeInBytes) {
if (privateScratchAllocation) {
privateScratchAllocation->updateTaskCount(currentTaskCount, osContext.getContextId());
csrAllocationStorage.storeAllocation(std::unique_ptr<GraphicsAllocation>(privateScratchAllocation), TEMPORARY_ALLOCATION);
}
privateScratchSizeBytes = requiredPrivateScratchSizeInBytes;
perThreadPrivateScratchSize = requiredPerThreadPrivateScratchSizeAlignedUp;
scratchSurfaceDirty = true;
AllocationProperties properties{this->rootDeviceIndex, true, privateScratchSizeBytes, AllocationType::PRIVATE_SURFACE, multiTileCapable, false, osContext.getDeviceBitfield()};
privateScratchAllocation = getMemoryManager()->allocateGraphicsMemoryWithProperties(properties);
}
}
}
void ScratchSpaceControllerXeHPAndLater::programHeaps(HeapContainer &heapContainer,
uint32_t scratchSlot,
uint32_t requiredPerThreadScratchSize,
uint32_t requiredPerThreadPrivateScratchSize,
uint32_t currentTaskCount,
OsContext &osContext,
bool &stateBaseAddressDirty,
bool &vfeStateDirty) {
sshOffset = scratchSlot;
updateSlots = false;
setRequiredScratchSpace(heapContainer[0]->getUnderlyingBuffer(), sshOffset, requiredPerThreadScratchSize, requiredPerThreadPrivateScratchSize, currentTaskCount, osContext, stateBaseAddressDirty, vfeStateDirty);
for (uint32_t i = 1; i < heapContainer.size(); ++i) {
surfaceStateHeap = static_cast<char *>(heapContainer[i]->getUnderlyingBuffer());
updateSlots = false;
programSurfaceState();
}
updateSlots = true;
}
} // namespace NEO
| 56.135514
| 214
| 0.640889
|
mattcarter2017
|
78d3c15eb43c582cd3409cfcf836e5e87acc4816
| 670
|
hpp
|
C++
|
external/boost_1_60_0/qsboost/mpl/advance_fwd.hpp
|
wouterboomsma/quickstep
|
a33447562eca1350c626883f21c68125bd9f776c
|
[
"MIT"
] | 1
|
2019-06-27T17:54:13.000Z
|
2019-06-27T17:54:13.000Z
|
external/boost_1_60_0/qsboost/mpl/advance_fwd.hpp
|
wouterboomsma/quickstep
|
a33447562eca1350c626883f21c68125bd9f776c
|
[
"MIT"
] | null | null | null |
external/boost_1_60_0/qsboost/mpl/advance_fwd.hpp
|
wouterboomsma/quickstep
|
a33447562eca1350c626883f21c68125bd9f776c
|
[
"MIT"
] | null | null | null |
#ifndef QSBOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
#define QSBOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Id$
// $Date$
// $Revision$
#include <qsboost/mpl/aux_/common_name_wknd.hpp>
namespace qsboost { namespace mpl {
QSBOOST_MPL_AUX_COMMON_NAME_WKND(advance)
template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;
}}
#endif // BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED
| 23.103448
| 62
| 0.773134
|
wouterboomsma
|
78d60a209dd1753a947441bc733d2cca0eb9dcda
| 1,554
|
cpp
|
C++
|
src/Sound/Sound.cpp
|
WapaMario63/PonyGL
|
3b170e53d9e98f55c70bc7947970e8c63dea62d9
|
[
"MIT"
] | 1
|
2017-02-07T22:42:15.000Z
|
2017-02-07T22:42:15.000Z
|
src/Sound/Sound.cpp
|
WapaMario63/PonyGL
|
3b170e53d9e98f55c70bc7947970e8c63dea62d9
|
[
"MIT"
] | null | null | null |
src/Sound/Sound.cpp
|
WapaMario63/PonyGL
|
3b170e53d9e98f55c70bc7947970e8c63dea62d9
|
[
"MIT"
] | null | null | null |
#include "Sound.h"
Sound::Sound(const char* file, SoundType type)
{
_filename = file;
_soundType = type;
if (_soundType == snd_BGM)
{
_sound = nullptr;
SetupBGM();
}
else if (_soundType == snd_SFX)
{
}
}
void Sound::SetupBGM()
{
_music.openFromFile(_filename);
std::cout << "Opened sound" << std::endl;
}
void Sound::SetupSFX()
{
}
void Sound::Play()
{
switch (_soundType)
{
case snd_BGM:
_music.play(); break;
case snd_SFX:
_sound->play(); break;
case snd_NONE:
std::cerr << "There is no sound to play u fuck" << std::endl;
}
}
void Sound::Pause()
{
switch (_soundType)
{
case snd_BGM:
_music.pause(); break;
case snd_SFX:
_sound->pause(); break;
case snd_NONE:
std::cerr << "There is no sound playing u fuck" << std::endl;
}
}
void Sound::Stop()
{
switch (_soundType)
{
case snd_BGM:
_music.stop(); break;
case snd_SFX:
_sound->stop(); break;
case snd_NONE:
std::cerr << "There is no sound to play u fuck" << std::endl;
}
}
void Sound::setVolume(float vol)
{
_music.setVolume(vol);
_sound->setVolume(vol);
}
void Sound::setPitch(float pitch)
{
_music.setPitch(pitch);
_sound->setPitch(pitch);
}
void Sound::setTime(float time)
{
sf::Time t = sf::seconds(time);
_music.setPlayingOffset(t);
_sound->setPlayingOffset(t);
}
void Sound::setLoop(bool loop)
{
_music.setLoop(loop);
_sound->setLoop(loop);
}
| 16.1875
| 69
| 0.579794
|
WapaMario63
|
78d84e9b0cff555cbec3472cb363986d0ae8935a
| 548
|
hpp
|
C++
|
src/modules/api/api_rest_error.hpp
|
dmortondev/openperf
|
dc142aa9bddcd578fd3491275cf36c016209df2e
|
[
"Apache-2.0"
] | null | null | null |
src/modules/api/api_rest_error.hpp
|
dmortondev/openperf
|
dc142aa9bddcd578fd3491275cf36c016209df2e
|
[
"Apache-2.0"
] | null | null | null |
src/modules/api/api_rest_error.hpp
|
dmortondev/openperf
|
dc142aa9bddcd578fd3491275cf36c016209df2e
|
[
"Apache-2.0"
] | null | null | null |
#ifndef _OP_API_REST_ERRORS_HPP_
#define _OP_API_REST_ERRORS_HPP_
#include <utility>
#include "json.hpp"
#include "pistache/http.h"
namespace openperf::api::rest {
enum class error_type { NONE = 0, NOT_FOUND, ZMQ_ERROR, POSIX };
struct typed_error
{
error_type type = error_type::NONE;
int value = 0;
};
std::pair<Pistache::Http::Code, std::optional<std::string>>
decode_error(const typed_error&);
nlohmann::json to_json(int code, std::string_view message);
} // namespace openperf::api::rest
#endif /* _OP_API_REST_ERRORS_HPP_ */
| 20.296296
| 64
| 0.737226
|
dmortondev
|
78d90ff3c41d7f4e3cc8781f36c9d883b307b34c
| 973
|
cpp
|
C++
|
Game/src/Game.cpp
|
xfanw/XjEngine
|
37ce289ede14445e7b1ed5a7a9c74e781c7eadab
|
[
"Apache-2.0"
] | null | null | null |
Game/src/Game.cpp
|
xfanw/XjEngine
|
37ce289ede14445e7b1ed5a7a9c74e781c7eadab
|
[
"Apache-2.0"
] | null | null | null |
Game/src/Game.cpp
|
xfanw/XjEngine
|
37ce289ede14445e7b1ed5a7a9c74e781c7eadab
|
[
"Apache-2.0"
] | null | null | null |
// Frank (32) Abstract VA
// Frank (33) Renderer
#include "Xj.h"
#include <Core\Application.h>
#include "imgui.h"
// TEMP
class ExampleLayer : public Xj::Layer {
public:
ExampleLayer() :Layer("Example") {}
void OnUpdate() override {
if (Xj::Input::IsKeyPressed(XJ_KEY_TAB))
XJ_INFO("Tab Key is pressed (poll)");
}
void OnEvent(Xj::Event& event) override {
if (event.GetEventType() == Xj::EventType::KeyPressed) {
Xj::KeyPressedEvent& e = (Xj::KeyPressedEvent&) event;
XJ_INFO("{0}", (char)e.GetKeyCode());
//TEST
if (Xj::Input::IsKeyPressed(XJ_KEY_TAB))
XJ_INFO("Tab Key is pressed (event)");
}
}
virtual void OnImGuiRender() override {
ImGui::Begin("Test");
ImGui::Text("Hello World");
ImGui::End();
}
};
class Game : public Xj::Application {
public:
Game() {
PushLayer(new ExampleLayer());
// PushOverlay(new Xj::ImGuiLayer());
}
~Game(){}
};
Xj::Application* Xj::CreateApplication() {
return new Game();
}
| 17.375
| 58
| 0.642343
|
xfanw
|
78dd9b8a1331cd1abb7448af36726533a261c986
| 1,082
|
hpp
|
C++
|
src/tree_diameter.hpp
|
keijak/hikidashi-cpp
|
63d01dfa1587fa56fd7f4e50712f7c10d8168520
|
[
"Apache-2.0"
] | null | null | null |
src/tree_diameter.hpp
|
keijak/hikidashi-cpp
|
63d01dfa1587fa56fd7f4e50712f7c10d8168520
|
[
"Apache-2.0"
] | null | null | null |
src/tree_diameter.hpp
|
keijak/hikidashi-cpp
|
63d01dfa1587fa56fd7f4e50712f7c10d8168520
|
[
"Apache-2.0"
] | null | null | null |
#include <algorithm>
#include <cassert>
#include <vector>
struct Diameter {
int distance;
std::vector<int> path;
};
// Tree diameter.
// Returns the maximum diameter and two endpoint nodes of the diameter.
Diameter tree_diameter(const std::vector<std::vector<int>> &g) {
std::vector<int> parent(g.size());
auto farthest = [&](auto &rec, int v, int p, int d) -> std::pair<int, int> {
parent[v] = p;
int rd = d, rv = v;
for (auto u : g[v]) {
if (u == p) continue;
const auto &[child_d, child_v] = rec(rec, u, v, d + 1);
if (child_d > rd) {
rd = child_d;
rv = child_v;
}
}
return {rd, rv};
};
const auto &[_, vr] = farthest(farthest, 0, -1, 0);
const auto &[distance, vl] = farthest(farthest, vr, -1, 0);
// Restore the path from vl to vr.
std::vector<int> diameter_path;
for (int v = vl; v != -1; v = parent[v]) {
diameter_path.push_back(v);
}
assert(diameter_path.back() == vr);
assert(int(diameter_path.size()) == distance + 1);
return Diameter{distance, std::move(diameter_path)};
}
| 25.761905
| 78
| 0.593346
|
keijak
|
78df313891d23140edf8f24c0cccb7d9106c32b4
| 1,100
|
hpp
|
C++
|
src/termui/file_status.hpp
|
numerodix/bmon-cpp
|
fae0613776b879a33e327f9ccf1d3819383634dd
|
[
"MIT"
] | 1
|
2020-07-31T01:34:47.000Z
|
2020-07-31T01:34:47.000Z
|
src/termui/file_status.hpp
|
numerodix/bmon-cpp
|
fae0613776b879a33e327f9ccf1d3819383634dd
|
[
"MIT"
] | null | null | null |
src/termui/file_status.hpp
|
numerodix/bmon-cpp
|
fae0613776b879a33e327f9ccf1d3819383634dd
|
[
"MIT"
] | null | null | null |
#ifndef FILE_STATUS_H
#define FILE_STATUS_H
#include <memory>
#include <macros.hpp>
namespace bandwit {
namespace termui {
class FileStatusSetter {
public:
explicit FileStatusSetter(int fileno, int status_on, int status_off)
: fileno_{fileno}, status_on_{status_on}, status_off_{status_off} {}
void set();
void reset();
private:
int fileno_{0};
int status_on_{0};
int status_off_{0};
int orig_status_{0};
};
class FileStatusSet {
public:
FileStatusSet &status_on(int status_on);
FileStatusSet &status_off(int status_off);
std::unique_ptr<FileStatusSetter> build_setter(int fileno);
private:
int status_on_{0};
int status_off_{0};
};
class FileStatusGuard {
public:
explicit FileStatusGuard(FileStatusSetter *setter) : setter_{setter} {
setter_->set();
}
~FileStatusGuard() { setter_->reset(); }
CLASS_DISABLE_COPIES(FileStatusGuard)
CLASS_DISABLE_MOVES(FileStatusGuard)
private:
FileStatusSetter *setter_{nullptr};
};
} // namespace termui
} // namespace bandwit
#endif // FILE_STATUS_H
| 20
| 76
| 0.700909
|
numerodix
|
78e33ebb5fcc9e693745f525dd7ed590f9e831b2
| 49,971
|
cpp
|
C++
|
opencl/test/unit_test/api/cl_create_image_tests.cpp
|
kcencele/compute-runtime
|
bec8cdd6f1392bf0549e3b9340b4926b6e84f89a
|
[
"Intel",
"MIT"
] | 1
|
2019-03-01T13:54:45.000Z
|
2019-03-01T13:54:45.000Z
|
opencl/test/unit_test/api/cl_create_image_tests.cpp
|
kcencele/compute-runtime
|
bec8cdd6f1392bf0549e3b9340b4926b6e84f89a
|
[
"Intel",
"MIT"
] | 5
|
2019-03-26T17:26:07.000Z
|
2021-03-30T12:17:10.000Z
|
opencl/test/unit_test/api/cl_create_image_tests.cpp
|
kcencele/compute-runtime
|
bec8cdd6f1392bf0549e3b9340b4926b6e84f89a
|
[
"Intel",
"MIT"
] | 4
|
2018-05-09T10:04:27.000Z
|
2018-07-12T13:33:31.000Z
|
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/helpers/hw_info.h"
#include "shared/test/common/helpers/unit_test_helper.h"
#include "shared/test/common/mocks/mock_device.h"
#include "opencl/source/context/context.h"
#include "opencl/source/mem_obj/image.h"
#include "opencl/test/unit_test/fixtures/image_fixture.h"
#include "opencl/test/unit_test/fixtures/multi_root_device_fixture.h"
#include "opencl/test/unit_test/mocks/mock_cl_device.h"
#include "opencl/test/unit_test/mocks/mock_memory_manager.h"
#include "opencl/test/unit_test/test_macros/test_checks_ocl.h"
#include "cl_api_tests.h"
using namespace NEO;
namespace ClCreateImageTests {
template <typename T>
struct clCreateImageTests : public ApiFixture<>,
public T {
void SetUp() override {
ApiFixture::SetUp();
// clang-format off
imageFormat.image_channel_order = CL_RGBA;
imageFormat.image_channel_data_type = CL_UNORM_INT8;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
imageDesc.image_width = 32;
imageDesc.image_height = 32;
imageDesc.image_depth = 1;
imageDesc.image_array_size = 1;
imageDesc.image_row_pitch = 0;
imageDesc.image_slice_pitch = 0;
imageDesc.num_mip_levels = 0;
imageDesc.num_samples = 0;
imageDesc.mem_object = nullptr;
// clang-format on
}
void TearDown() override {
ApiFixture::TearDown();
}
cl_image_format imageFormat;
cl_image_desc imageDesc;
};
typedef clCreateImageTests<::testing::Test> clCreateImageTest;
TEST_F(clCreateImageTest, GivenNullHostPtrWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingTiledImageThenInvalidOperationErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
mockClDevice.sharedDeviceInfo.imageSupport = CL_FALSE;
cl_bool imageSupportInfo = CL_TRUE;
auto status = clGetDeviceInfo(&mockClDevice, CL_DEVICE_IMAGE_SUPPORT, sizeof(imageSupportInfo), &imageSupportInfo, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
cl_bool expectedValue = CL_FALSE;
EXPECT_EQ(expectedValue, imageSupportInfo);
auto image = clCreateImage(
&mockContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
if (UnitTestHelper<FamilyType>::tiledImagesSupported) {
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, image);
} else {
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
}
HWTEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingNonTiledImageThenCreate) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
mockClDevice.sharedDeviceInfo.imageSupport = CL_FALSE;
cl_bool imageSupportInfo = CL_TRUE;
auto status = clGetDeviceInfo(&mockClDevice, CL_DEVICE_IMAGE_SUPPORT, sizeof(imageSupportInfo), &imageSupportInfo, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
cl_bool expectedValue = CL_FALSE;
EXPECT_EQ(expectedValue, imageSupportInfo);
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc.image_height = 1;
auto image = clCreateImage(
&mockContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImageWithPropertiesINTELThenImageCreatedAndSuccessIsReturned) {
DebugManagerStateRestore stateRestore;
MockClDevice mockClDevice{MockDevice::createWithNewExecutionEnvironment<MockDevice>(defaultHwInfo.get(), 0)};
MockContext mockContext{&mockClDevice};
mockClDevice.sharedDeviceInfo.imageSupport = CL_FALSE;
cl_bool imageSupportInfo = CL_TRUE;
auto status = clGetDeviceInfo(&mockClDevice, CL_DEVICE_IMAGE_SUPPORT, sizeof(imageSupportInfo), &imageSupportInfo, nullptr);
EXPECT_EQ(CL_SUCCESS, status);
cl_bool expectedValue = CL_FALSE;
EXPECT_EQ(expectedValue, imageSupportInfo);
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
imageDesc.image_height = 1;
DebugManager.flags.ForceLinearImages.set(true);
auto image = clCreateImageWithPropertiesINTEL(
&mockContext,
nullptr,
0,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithPropertiesAndWithoutThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage(pContext.get(), CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, image);
auto imageWithProperties = clCreateImageWithProperties(pContext.get(), nullptr, CL_MEM_READ_WRITE, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
EXPECT_EQ(nullptr, imageWithProperties);
}
TEST_F(clCreateImageTest, GivenNullContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
auto image = clCreateImageWithProperties(
nullptr,
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndAlignedRowPitchWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 128;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
&imageFormat,
&imageDesc,
hostPtr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndUnalignedRowPitchWhenCreatingImageThenInvalidImageDescriptotErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 129;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
&imageFormat,
&imageDesc,
hostPtr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNonNullHostPtrAndSmallRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
&imageFormat,
&imageDesc,
hostPtr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenUnrestrictedIntelFlagWhenCreatingImageWithInvalidFlagCombinationThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY | CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL;
auto image = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndNoHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char hostPtr[4096];
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
hostPtr,
&retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = (1 << 12);
auto image = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, GivenInvalidFlagBitsWhenCreatingImageFromAnotherImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageFormat.image_channel_order = CL_RG;
imageDesc.mem_object = image;
cl_mem_flags flags = (1 << 30);
auto imageFromImageObject = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(imageFromImageObject);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, GivenInvalidRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 655;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndCopyHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndMemUseHostPtrFlagWhenCreatingImageThenInvalidHostPtrErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_HOST_PTR, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageTest, GivenNullHostPtrAndNonZeroRowPitchWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 4;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, GivenDeviceNotSupportingImagesWhenCreatingImageFromBufferThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto buffer = clCreateBuffer(pContext.get(), CL_MEM_READ_WRITE, 4096 * 9, nullptr, nullptr);
imageDesc.mem_object = buffer;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
auto image = clCreateImageWithPropertiesINTEL(
pContext.get(),
nullptr,
0,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(nullptr, image);
EXPECT_EQ(CL_INVALID_OPERATION, retVal);
clReleaseMemObject(buffer);
}
TEST_F(clCreateImageTest, GivenNonZeroPitchWhenCreatingImageFromBufferThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
auto buffer = clCreateBuffer(pContext, CL_MEM_READ_WRITE, 4096 * 9, nullptr, nullptr);
auto &helper = HwHelper::get(renderCoreFamily);
HardwareInfo hardwareInfo = *defaultHwInfo;
imageDesc.mem_object = buffer;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE2D;
imageDesc.image_width = 17;
imageDesc.image_height = 17;
imageDesc.image_row_pitch = helper.getPitchAlignmentForImage(&hardwareInfo) * 17;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_NE(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_NE(nullptr, image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(buffer);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageTest, GivenNotNullHostPtrAndRowPitchIsNotGreaterThanWidthTimesElementSizeWhenCreatingImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_row_pitch = 64;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, GivenNullContextWhenCreatingImageThenInvalidContextErrorIsReturned) {
auto image = clCreateImage(
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenParametersAreCorrectlyPassed) {
VariableBackup<ImageFunctions::ValidateAndCreateImageFunc> imageCreateBackup{&ImageFunctions::validateAndCreateImage};
cl_context context = pContext;
cl_mem_properties *propertiesValues[] = {nullptr, reinterpret_cast<cl_mem_properties *>(0x1234)};
cl_mem_flags flagsValues[] = {0, 4321};
cl_image_format imageFormat = this->imageFormat;
cl_image_desc imageDesc = this->imageDesc;
void *pHostMem = reinterpret_cast<void *>(0x8000);
for (auto properties : propertiesValues) {
for (auto flags : flagsValues) {
auto mockFunction = [context, properties, flags, &imageFormat, &imageDesc, pHostMem](cl_context contextArg,
const cl_mem_properties *propertiesArg,
cl_mem_flags flagsArg,
cl_mem_flags_intel flagsIntelArg,
const cl_image_format *imageFormatArg,
const cl_image_desc *imageDescArg,
const void *hostPtrArg,
cl_int &errcodeRetArg) -> cl_mem {
cl_mem_flags_intel expectedFlagsIntelArg = 0;
EXPECT_EQ(context, contextArg);
EXPECT_EQ(properties, propertiesArg);
EXPECT_EQ(flags, flagsArg);
EXPECT_EQ(expectedFlagsIntelArg, flagsIntelArg);
EXPECT_EQ(&imageFormat, imageFormatArg);
EXPECT_EQ(&imageDesc, imageDescArg);
EXPECT_EQ(pHostMem, hostPtrArg);
return nullptr;
};
imageCreateBackup = mockFunction;
clCreateImageWithProperties(context, properties, flags, &imageFormat, &imageDesc, pHostMem, nullptr);
}
}
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenErrorCodeIsCorrectlySet) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
VariableBackup<ImageFunctions::ValidateAndCreateImageFunc> imageCreateBackup{&ImageFunctions::validateAndCreateImage};
cl_mem_properties *properties = nullptr;
cl_mem_flags flags = 0;
void *pHostMem = nullptr;
cl_int errcodeRet;
cl_int retValues[] = {CL_SUCCESS, CL_INVALID_PROPERTY};
for (auto retValue : retValues) {
auto mockFunction = [retValue](cl_context contextArg,
const cl_mem_properties *propertiesArg,
cl_mem_flags flagsArg,
cl_mem_flags_intel flagsIntelArg,
const cl_image_format *imageFormatArg,
const cl_image_desc *imageDescArg,
const void *hostPtrArg,
cl_int &errcodeRetArg) -> cl_mem {
errcodeRetArg = retValue;
return nullptr;
};
imageCreateBackup = mockFunction;
clCreateImageWithProperties(pContext, properties, flags, &imageFormat, &imageDesc, pHostMem, &errcodeRet);
EXPECT_EQ(retValue, errcodeRet);
}
}
TEST_F(clCreateImageTest, GivenImageCreatedWithNullPropertiesWhenQueryingPropertiesThenNothingIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
auto image = clCreateImageWithProperties(pContext, nullptr, 0, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_NE(nullptr, image);
size_t propertiesSize;
retVal = clGetMemObjectInfo(image, CL_MEM_PROPERTIES, 0, nullptr, &propertiesSize);
EXPECT_EQ(retVal, CL_SUCCESS);
EXPECT_EQ(0u, propertiesSize);
clReleaseMemObject(image);
}
TEST_F(clCreateImageTest, WhenCreatingImageWithPropertiesThenPropertiesAreCorrectlyStored) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_int retVal = CL_SUCCESS;
cl_mem_properties properties[5];
size_t propertiesSize;
std::vector<std::vector<uint64_t>> propertiesToTest{
{0},
{CL_MEM_FLAGS, CL_MEM_WRITE_ONLY, 0},
{CL_MEM_FLAGS_INTEL, CL_MEM_LOCALLY_UNCACHED_RESOURCE, 0},
{CL_MEM_FLAGS, CL_MEM_WRITE_ONLY, CL_MEM_FLAGS_INTEL, CL_MEM_LOCALLY_UNCACHED_RESOURCE, 0}};
for (auto testProperties : propertiesToTest) {
auto image = clCreateImageWithProperties(pContext, testProperties.data(), 0, &imageFormat, &imageDesc, nullptr, &retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clGetMemObjectInfo(image, CL_MEM_PROPERTIES, sizeof(properties), properties, &propertiesSize);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(testProperties.size() * sizeof(cl_mem_properties), propertiesSize);
for (size_t i = 0; i < testProperties.size(); i++) {
EXPECT_EQ(testProperties[i], properties[i]);
}
clReleaseMemObject(image);
}
}
typedef clCreateImageTests<::testing::Test> clCreateImageTestYUV;
TEST_F(clCreateImageTestYUV, GivenInvalidGlagWhenCreatingYuvImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
TEST_F(clCreateImageTestYUV, Given1DImageTypeWhenCreatingYuvImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_YUYV_INTEL;
imageDesc.image_type = CL_MEM_OBJECT_IMAGE1D;
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
typedef clCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageValidFlags;
static cl_mem_flags validFlags[] = {
CL_MEM_READ_WRITE,
CL_MEM_WRITE_ONLY,
CL_MEM_READ_ONLY,
CL_MEM_USE_HOST_PTR,
CL_MEM_ALLOC_HOST_PTR,
CL_MEM_COPY_HOST_PTR,
CL_MEM_HOST_WRITE_ONLY,
CL_MEM_HOST_READ_ONLY,
CL_MEM_HOST_NO_ACCESS,
CL_MEM_NO_ACCESS_INTEL,
CL_MEM_FORCE_LINEAR_STORAGE_INTEL,
CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL,
};
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageValidFlags,
::testing::ValuesIn(validFlags));
TEST_P(clCreateImageValidFlags, GivenValidFlagsWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
cl_mem_flags flags = GetParam();
std::unique_ptr<char[]> ptr;
char *hostPtr = nullptr;
if (flags & CL_MEM_USE_HOST_PTR ||
flags & CL_MEM_COPY_HOST_PTR) {
ptr = std::make_unique<char[]>(alignUp(imageDesc.image_width * imageDesc.image_height * 4, MemoryConstants::pageSize));
hostPtr = ptr.get();
}
auto image = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
hostPtr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
typedef clCreateImageTests<::testing::TestWithParam<uint64_t>> clCreateImageInvalidFlags;
static cl_mem_flags invalidFlagsCombinations[] = {
CL_MEM_READ_WRITE | CL_MEM_WRITE_ONLY,
CL_MEM_READ_WRITE | CL_MEM_READ_ONLY,
CL_MEM_WRITE_ONLY | CL_MEM_READ_ONLY,
CL_MEM_ALLOC_HOST_PTR | CL_MEM_USE_HOST_PTR,
CL_MEM_COPY_HOST_PTR | CL_MEM_USE_HOST_PTR,
CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_READ_ONLY,
CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS,
CL_MEM_HOST_READ_ONLY | CL_MEM_HOST_NO_ACCESS,
CL_MEM_NO_ACCESS_INTEL | CL_MEM_READ_WRITE,
CL_MEM_NO_ACCESS_INTEL | CL_MEM_WRITE_ONLY,
CL_MEM_NO_ACCESS_INTEL | CL_MEM_READ_ONLY};
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageInvalidFlags,
::testing::ValuesIn(invalidFlagsCombinations));
TEST_P(clCreateImageInvalidFlags, GivenInvalidFlagsCombinationsWhenCreatingImageThenInvalidValueErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
char ptr[10];
imageDesc.image_row_pitch = 128;
cl_mem_flags flags = GetParam();
auto image = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
ptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
cl_mem_properties_intel properties[] = {CL_MEM_FLAGS, flags, 0};
image = clCreateImageWithPropertiesINTEL(
pContext,
properties,
0,
&imageFormat,
&imageDesc,
ptr,
&retVal);
ASSERT_EQ(CL_INVALID_PROPERTY, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
image = clCreateImageWithPropertiesINTEL(
pContext,
nullptr,
flags,
&imageFormat,
&imageDesc,
ptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
struct ImageFlags {
cl_mem_flags parentFlags;
cl_mem_flags flags;
};
static ImageFlags flagsWithUnrestrictedIntel[] = {
{CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL, CL_MEM_READ_WRITE},
{CL_MEM_READ_WRITE, CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageFlagsUnrestrictedIntel;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageFlagsUnrestrictedIntel,
::testing::ValuesIn(flagsWithUnrestrictedIntel));
TEST_P(clCreateImageFlagsUnrestrictedIntel, GivenFlagsIncludingUnrestrictedIntelWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
ImageFlags imageFlags = GetParam();
cl_mem_flags parentFlags = imageFlags.parentFlags;
cl_mem_flags flags = imageFlags.flags;
auto image = clCreateImage(
pContext,
parentFlags | CL_MEM_HOST_NO_ACCESS,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageDesc.mem_object = image;
imageFormat.image_channel_order = CL_RG;
auto imageFromImageObject = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(imageFromImageObject);
EXPECT_EQ(CL_SUCCESS, retVal);
}
static ImageFlags validFlagsAndParentFlags[] = {
{CL_MEM_WRITE_ONLY, CL_MEM_HOST_NO_ACCESS},
{CL_MEM_READ_ONLY, CL_MEM_HOST_NO_ACCESS},
{CL_MEM_NO_ACCESS_INTEL, CL_MEM_HOST_NO_ACCESS},
{CL_MEM_HOST_NO_ACCESS, CL_MEM_READ_WRITE}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageValidFlagsAndParentFlagsCombinations;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageValidFlagsAndParentFlagsCombinations,
::testing::ValuesIn(validFlagsAndParentFlags));
TEST_P(clCreateImageValidFlagsAndParentFlagsCombinations, GivenValidFlagsAndParentFlagsWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
ImageFlags imageFlags = GetParam();
cl_mem_flags parentFlags = imageFlags.parentFlags;
cl_mem_flags flags = imageFlags.flags;
auto image = clCreateImage(
pContext,
parentFlags | CL_MEM_HOST_NO_ACCESS,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageDesc.mem_object = image;
imageFormat.image_channel_order = CL_RG;
auto imageFromImageObject = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(imageFromImageObject);
EXPECT_EQ(CL_SUCCESS, retVal);
}
static ImageFlags invalidFlagsAndParentFlags[] = {
{CL_MEM_WRITE_ONLY, CL_MEM_READ_WRITE},
{CL_MEM_WRITE_ONLY, CL_MEM_READ_ONLY},
{CL_MEM_READ_ONLY, CL_MEM_READ_WRITE},
{CL_MEM_READ_ONLY, CL_MEM_WRITE_ONLY},
{CL_MEM_NO_ACCESS_INTEL, CL_MEM_READ_WRITE},
{CL_MEM_NO_ACCESS_INTEL, CL_MEM_WRITE_ONLY},
{CL_MEM_NO_ACCESS_INTEL, CL_MEM_READ_ONLY},
{CL_MEM_HOST_NO_ACCESS, CL_MEM_HOST_WRITE_ONLY},
{CL_MEM_HOST_NO_ACCESS, CL_MEM_HOST_READ_ONLY}};
typedef clCreateImageTests<::testing::TestWithParam<ImageFlags>> clCreateImageInvalidFlagsAndParentFlagsCombinations;
INSTANTIATE_TEST_CASE_P(CreateImageWithFlags,
clCreateImageInvalidFlagsAndParentFlagsCombinations,
::testing::ValuesIn(invalidFlagsAndParentFlags));
TEST_P(clCreateImageInvalidFlagsAndParentFlagsCombinations, GivenInvalidFlagsAndParentFlagsWhenCreatingImageThenInvalidMemObjectErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_NV12_INTEL;
ImageFlags imageFlags = GetParam();
cl_mem_flags parentFlags = imageFlags.parentFlags;
cl_mem_flags flags = imageFlags.flags;
auto image = clCreateImage(
pContext,
parentFlags | CL_MEM_HOST_NO_ACCESS,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageFormat.image_channel_order = CL_RG;
imageDesc.mem_object = image;
auto imageFromImageObject = clCreateImage(
pContext,
flags,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_VALUE, retVal);
EXPECT_EQ(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(imageFromImageObject);
EXPECT_EQ(CL_INVALID_MEM_OBJECT, retVal);
}
struct ImageSizes {
size_t width;
size_t height;
size_t depth;
};
ImageSizes validImage2DSizes[] = {{64, 64, 1}, {3, 3, 1}, {8192, 1, 1}, {117, 39, 1}, {16384, 4, 1}, {4, 16384, 1}};
typedef clCreateImageTests<::testing::TestWithParam<ImageSizes>> clCreateImageValidSizesTest;
INSTANTIATE_TEST_CASE_P(validImage2DSizes,
clCreateImageValidSizesTest,
::testing::ValuesIn(validImage2DSizes));
TEST_P(clCreateImageValidSizesTest, GivenValidSizesWhenCreatingImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
ImageSizes sizes = GetParam();
imageDesc.image_width = sizes.width;
imageDesc.image_height = sizes.height;
imageDesc.image_depth = sizes.depth;
auto image = clCreateImage(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_NE(nullptr, image);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clReleaseMemObject(image);
}
typedef clCreateImageTests<::testing::Test> clCreateImage2DTest;
TEST_F(clCreateImage2DTest, GivenValidParametersWhenCreating2DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImage2DTest, GivenNoPtrToReturnValueWhenCreating2DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage2D(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
nullptr);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImage2DTest, GivenInvalidContextsWhenCreating2DImageThenInvalidContextErrorIsReturned) {
auto image = clCreateImage2D(
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
&retVal);
EXPECT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage2DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage2DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage2D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImage3DTest;
TEST_F(clCreateImage3DTest, GivenValidParametersWhenCreating3DImageThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
&retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImage3DTest, GivenNoPtrToReturnValueWhenCreating3DImageThenImageIsCreated) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
auto image = clCreateImage3D(
pContext,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
nullptr);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImage3DTest, GivenInvalidContextsWhenCreating3DImageThenInvalidContextErrorIsReturned) {
auto image = clCreateImage3D(
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
&retVal);
EXPECT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImage3DTest, GivenDeviceThatDoesntSupportImagesWhenCreatingImagesWithclCreateImage3DThenInvalidOperationErrorIsReturned) {
auto hardwareInfo = *defaultHwInfo;
hardwareInfo.capabilityTable.supportsImages = false;
auto pClDevice = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hardwareInfo, 0));
cl_device_id deviceId = pClDevice.get();
auto pContext = std::unique_ptr<MockContext>(Context::create<MockContext>(nullptr, ClDeviceVector(&deviceId, 1), nullptr, nullptr, retVal));
auto image = clCreateImage3D(
pContext.get(),
CL_MEM_READ_WRITE,
&imageFormat,
10,
10,
1,
0,
0,
0,
&retVal);
ASSERT_EQ(nullptr, image);
ASSERT_EQ(CL_INVALID_OPERATION, retVal);
}
using clCreateImageWithPropertiesINTELTest = clCreateImageTest;
TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidContextWhenCreatingImageWithPropertiesThenInvalidContextErrorIsReturned) {
auto image = clCreateImageWithPropertiesINTEL(
nullptr,
nullptr,
0,
nullptr,
nullptr,
nullptr,
&retVal);
ASSERT_EQ(CL_INVALID_CONTEXT, retVal);
EXPECT_EQ(nullptr, image);
}
TEST_F(clCreateImageWithPropertiesINTELTest, GivenValidParametersWhenCreatingImageWithPropertiesThenImageIsCreatedAndSuccessReturned) {
cl_mem_properties_intel properties[] = {CL_MEM_FLAGS, CL_MEM_READ_WRITE, 0};
auto image = clCreateImageWithPropertiesINTEL(
pContext,
properties,
0,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
image = clCreateImageWithPropertiesINTEL(
pContext,
nullptr,
CL_MEM_READ_WRITE,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageWithPropertiesINTELTest, GivenInvalidPropertyKeyWhenCreatingImageWithPropertiesThenInvalidValueErrorIsReturned) {
cl_mem_properties_intel properties[] = {(cl_mem_properties_intel(1) << 31), 0, 0};
auto image = clCreateImageWithPropertiesINTEL(
pContext,
properties,
0,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(nullptr, image);
EXPECT_EQ(CL_INVALID_PROPERTY, retVal);
}
typedef clCreateImageTests<::testing::Test> clCreateImageFromImageTest;
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndValidFormatThenImageIsCreatedAndSuccessReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
imageDesc.mem_object = image;
imageFormat.image_channel_order = CL_sBGRA;
auto imageFromImageObject = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
if (pContext->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features == false) {
EXPECT_EQ(CL_IMAGE_FORMAT_NOT_SUPPORTED, retVal);
EXPECT_EQ(nullptr, imageFromImageObject);
} else {
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(imageFromImageObject);
EXPECT_EQ(CL_SUCCESS, retVal);
}
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithDifferentDescriptorAndValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
imageDesc.mem_object = image;
imageDesc.image_width++;
imageFormat.image_channel_order = CL_sBGRA;
auto imageFromImageObject = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
if (pContext->getDevice(0)->getHardwareInfo().capabilityTable.supportsOcl21Features) {
EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal);
} else {
EXPECT_EQ(CL_IMAGE_FORMAT_NOT_SUPPORTED, retVal);
}
EXPECT_EQ(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
TEST_F(clCreateImageFromImageTest, GivenImage2dWhenCreatingImage2dFromImageWithTheSameDescriptorAndNotValidFormatThenInvalidImageFormatDescriptorErrorIsReturned) {
REQUIRE_IMAGES_OR_SKIP(pContext);
imageFormat.image_channel_order = CL_BGRA;
auto image = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
ASSERT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_width), &imageDesc.image_width, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(imageDesc.image_height), &imageDesc.image_height, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_DEPTH, sizeof(imageDesc.image_depth), &imageDesc.image_depth, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ROW_PITCH, sizeof(imageDesc.image_row_pitch), &imageDesc.image_row_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_SLICE_PITCH, sizeof(imageDesc.image_slice_pitch), &imageDesc.image_slice_pitch, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_MIP_LEVELS, sizeof(imageDesc.num_mip_levels), &imageDesc.num_mip_levels, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_NUM_SAMPLES, sizeof(imageDesc.num_samples), &imageDesc.num_samples, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
retVal = clGetImageInfo(image, CL_IMAGE_ARRAY_SIZE, sizeof(imageDesc.image_array_size), &imageDesc.image_array_size, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
imageDesc.mem_object = image;
imageFormat.image_channel_order = CL_BGRA;
auto imageFromImageObject = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, imageFromImageObject);
retVal = clReleaseMemObject(image);
EXPECT_EQ(CL_SUCCESS, retVal);
}
uint32_t non2dImageTypes[] = {CL_MEM_OBJECT_IMAGE1D, CL_MEM_OBJECT_IMAGE1D_ARRAY, CL_MEM_OBJECT_IMAGE1D_BUFFER, CL_MEM_OBJECT_IMAGE2D_ARRAY, CL_MEM_OBJECT_IMAGE3D};
struct clCreateNon2dImageFromImageTest : public clCreateImageFromImageTest,
public ::testing::WithParamInterface<uint32_t /*image type*/> {
void SetUp() override {
clCreateImageFromImageTest::SetUp();
image = ImageFunctions::validateAndCreateImage(pContext, nullptr, CL_MEM_READ_ONLY, 0, &imageFormat, &imageDesc, nullptr, retVal);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, image);
imageDesc.mem_object = image;
}
void TearDown() override {
retVal = clReleaseMemObject(image);
clCreateImageFromImageTest::TearDown();
}
cl_mem image;
};
TEST_P(clCreateNon2dImageFromImageTest, GivenImage2dWhenCreatingImageFromNon2dImageThenInvalidImageDescriptorErrorIsReturned) {
REQUIRE_IMAGE_SUPPORT_OR_SKIP(pContext);
imageDesc.image_type = GetParam();
auto imageFromImageObject = clCreateImage(
pContext,
CL_MEM_READ_ONLY,
&imageFormat,
&imageDesc,
nullptr,
&retVal);
EXPECT_EQ(CL_INVALID_IMAGE_DESCRIPTOR, retVal);
EXPECT_EQ(nullptr, imageFromImageObject);
}
INSTANTIATE_TEST_CASE_P(clCreateNon2dImageFromImageTests,
clCreateNon2dImageFromImageTest,
::testing::ValuesIn(non2dImageTypes));
using clCreateImageWithMultiDeviceContextTests = MultiRootDeviceFixture;
TEST_F(clCreateImageWithMultiDeviceContextTests, GivenImageCreatedWithoutHostPtrAndWithContextdWithMultiDeviceThenGraphicsAllocationsAreProperlyCreatedAndMapPtrIsSet) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
DebugManagerStateRestore dbgRestore;
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(image->getMultiGraphicsAllocation().getGraphicsAllocations().size(), 3u);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), nullptr);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(2u), nullptr);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), image->getMultiGraphicsAllocation().getGraphicsAllocation(2u));
EXPECT_TRUE(MemoryPool::isSystemMemoryPool(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u)->getMemoryPool()));
EXPECT_TRUE(MemoryPool::isSystemMemoryPool(image->getMultiGraphicsAllocation().getGraphicsAllocation(2u)->getMemoryPool()));
EXPECT_NE(image->getAllocatedMapPtr(), nullptr);
}
TEST_F(clCreateImageWithMultiDeviceContextTests, GivenImageCreatedWithHostPtrAndWithContextdWithMultiDeviceThenGraphicsAllocationsAreProperlyCreatedAndMapPtrIsNotSet) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
DebugManagerStateRestore dbgRestore;
std::unique_ptr<Image> image(ImageHelper<ImageUseHostPtr<Image1dDefaults>>::create(context.get()));
EXPECT_EQ(image->getMultiGraphicsAllocation().getGraphicsAllocations().size(), 3u);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), nullptr);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(2u), nullptr);
EXPECT_NE(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u), image->getMultiGraphicsAllocation().getGraphicsAllocation(2u));
EXPECT_TRUE(MemoryPool::isSystemMemoryPool(image->getMultiGraphicsAllocation().getGraphicsAllocation(1u)->getMemoryPool()));
EXPECT_TRUE(MemoryPool::isSystemMemoryPool(image->getMultiGraphicsAllocation().getGraphicsAllocation(2u)->getMemoryPool()));
EXPECT_EQ(image->getAllocatedMapPtr(), nullptr);
}
TEST_F(clCreateImageWithMultiDeviceContextTests, GivenContextdWithMultiDeviceFailingAllocationThenImageAllocateFails) {
REQUIRE_IMAGES_OR_SKIP(defaultHwInfo);
{
static_cast<MockMemoryManager *>(context.get()->getMemoryManager())->successAllocatedGraphicsMemoryIndex = 0u;
static_cast<MockMemoryManager *>(context.get()->getMemoryManager())->maxSuccessAllocatedGraphicsMemoryIndex = 0u;
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(nullptr, image);
}
{
static_cast<MockMemoryManager *>(context.get()->getMemoryManager())->successAllocatedGraphicsMemoryIndex = 0u;
static_cast<MockMemoryManager *>(context.get()->getMemoryManager())->maxSuccessAllocatedGraphicsMemoryIndex = 1u;
std::unique_ptr<Image> image(ImageHelper<ImageWithoutHostPtr>::create(context.get()));
EXPECT_EQ(nullptr, image);
}
}
} // namespace ClCreateImageTests
| 35.091994
| 168
| 0.711973
|
kcencele
|
78e377f26bd1f7e583c1d0d264a7350ff95e74ef
| 706
|
cpp
|
C++
|
Lesson6/Triangle/triangle.cpp
|
gonini/Codility-Lesson
|
c362a7357752b2cf89b9ad92d9e512c97b988a4e
|
[
"MIT"
] | null | null | null |
Lesson6/Triangle/triangle.cpp
|
gonini/Codility-Lesson
|
c362a7357752b2cf89b9ad92d9e512c97b988a4e
|
[
"MIT"
] | null | null | null |
Lesson6/Triangle/triangle.cpp
|
gonini/Codility-Lesson
|
c362a7357752b2cf89b9ad92d9e512c97b988a4e
|
[
"MIT"
] | null | null | null |
// you can use includes, for example:
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <cstring>
#include <set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int solution(vector<int> &A);
int main(void) {
vector<int> A = {10, 2, 5, 1, 8, 20};
cout << solution(A) << "\n";
}
int solution(vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
if (A.size() < 3) {
return 0;
}
sort(A.begin(), A.end());
for(int i = 0; i < A.size() - 2; i++) {
if(A[i] > 0 && A[i+1] > A[i+2] - A[i]) {
return 1;
}
}
return 0;
}
| 20.171429
| 55
| 0.526912
|
gonini
|
78e86ba9a0d9913e2e955f4cecb50452834c54e1
| 1,229
|
hpp
|
C++
|
library/src/blas1/rocblas_amax_amin.hpp
|
amcamd/rocBLAS
|
f0986a922269c2fe343c414ec13a055cf8574bc3
|
[
"MIT"
] | null | null | null |
library/src/blas1/rocblas_amax_amin.hpp
|
amcamd/rocBLAS
|
f0986a922269c2fe343c414ec13a055cf8574bc3
|
[
"MIT"
] | null | null | null |
library/src/blas1/rocblas_amax_amin.hpp
|
amcamd/rocBLAS
|
f0986a922269c2fe343c414ec13a055cf8574bc3
|
[
"MIT"
] | null | null | null |
/* ************************************************************************
* Copyright 2018-2020 Advanced Micro Devices, Inc.
* ************************************************************************ */
#pragma once
#include "rocblas_reduction_template.hpp"
//!
//! @brief Struct-operator a default_value of rocblas_index_value_t<T>
//!
template <typename T>
struct rocblas_default_value<rocblas_index_value_t<T>>
{
__forceinline__ __host__ __device__ constexpr auto operator()() const
{
rocblas_index_value_t<T> x;
x.index = -1;
return x;
}
};
//!
//! @brief Struct-operator to fetch absolute value
//!
template <typename To>
struct rocblas_fetch_amax_amin
{
template <typename Ti>
__forceinline__ __host__ __device__ rocblas_index_value_t<To> operator()(Ti x,
rocblas_int index)
{
return {index, fetch_asum(x)};
}
};
//!
//! @brief Struct-operator to finalize the data.
//!
struct rocblas_finalize_amax_amin
{
template <typename To>
__forceinline__ __host__ __device__ auto operator()(const rocblas_index_value_t<To>& x)
{
return x.index + 1;
}
};
| 25.604167
| 95
| 0.558991
|
amcamd
|
78ef4f08d8a165c04c23503148476fb2e91fe5ca
| 117
|
cpp
|
C++
|
Basics/Destructors/music.cpp
|
srini1392/Programming-in-Cpp
|
099f44d65cbe976b27625e5806b32ab88414b019
|
[
"MIT"
] | null | null | null |
Basics/Destructors/music.cpp
|
srini1392/Programming-in-Cpp
|
099f44d65cbe976b27625e5806b32ab88414b019
|
[
"MIT"
] | null | null | null |
Basics/Destructors/music.cpp
|
srini1392/Programming-in-Cpp
|
099f44d65cbe976b27625e5806b32ab88414b019
|
[
"MIT"
] | null | null | null |
#include <iostream>
#include "song.hpp"
int main() {
Song back_to_black("Back to Black", "Amy Winehouse");
}
| 14.625
| 55
| 0.649573
|
srini1392
|
78f146e4f4b81f38ee25ea00821910807fa270ec
| 5,261
|
hpp
|
C++
|
src/umpire/util/AllocationMap.hpp
|
agcapps/Umpire
|
ecea50674437a3cac09fab53e5b842979158b44b
|
[
"MIT-0",
"MIT"
] | null | null | null |
src/umpire/util/AllocationMap.hpp
|
agcapps/Umpire
|
ecea50674437a3cac09fab53e5b842979158b44b
|
[
"MIT-0",
"MIT"
] | null | null | null |
src/umpire/util/AllocationMap.hpp
|
agcapps/Umpire
|
ecea50674437a3cac09fab53e5b842979158b44b
|
[
"MIT-0",
"MIT"
] | null | null | null |
//////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2016-20, Lawrence Livermore National Security, LLC and Umpire
// project contributors. See the COPYRIGHT file for details.
//
// SPDX-License-Identifier: (MIT)
//////////////////////////////////////////////////////////////////////////////
#ifndef UMPIRE_AllocationMap_HPP
#define UMPIRE_AllocationMap_HPP
// AllocationMap is a multimap of addresses to addresses. It uses Judy
// for the map, with an array-like object to hold multiple values with
// the same key.
#include "umpire/util/AllocationRecord.hpp"
#include "umpire/util/MemoryMap.hpp"
#include <cstdint>
#include <iostream>
#include <iterator>
#include <functional>
namespace umpire {
namespace util {
class AllocationMap
{
class RecordList
{
public:
template <typename T>
struct Block
{
T rec;
Block* prev;
};
using RecordBlock = Block<AllocationRecord>;
// Iterator for RecordList
class ConstIterator
{
public:
using iterator_category = std::forward_iterator_tag;
using value_type = AllocationRecord;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
ConstIterator();
ConstIterator(const RecordList* list, iterator_begin);
ConstIterator(const RecordList* list, iterator_end);
ConstIterator(const ConstIterator&) = default;
const AllocationRecord& operator*();
const AllocationRecord* operator->();
ConstIterator& operator++();
ConstIterator operator++(int);
bool operator==(const ConstIterator& other) const;
bool operator!=(const ConstIterator& other) const;
private:
const RecordList *m_list;
RecordBlock* m_curr;
};
RecordList(AllocationMap& map, AllocationRecord record);
~RecordList();
void push_back(const AllocationRecord& rec);
AllocationRecord pop_back();
ConstIterator begin() const;
ConstIterator end() const;
std::size_t size() const;
bool empty() const;
AllocationRecord* back();
const AllocationRecord* back() const;
private:
AllocationMap& m_map;
RecordBlock* m_tail;
std::size_t m_length;
};
public:
using Map = MemoryMap<RecordList>;
// Iterator that flattens MemoryMap and RecordList iterators
class ConstIterator
{
public:
using iterator_category = std::forward_iterator_tag;
using value_type = AllocationRecord;
using difference_type = std::ptrdiff_t;
using pointer = value_type*;
using reference = value_type&;
// Iterator(AllocationMap* map, const OuterIterType& outer_iter, const InnerIterType& inner_iter);
ConstIterator(const AllocationMap* map, iterator_begin);
ConstIterator(const AllocationMap* map, iterator_end);
ConstIterator(const ConstIterator&) = default;
const AllocationRecord& operator*();
const AllocationRecord* operator->();
ConstIterator& operator++();
ConstIterator operator++(int);
bool operator==(const ConstIterator& other) const;
bool operator!=(const ConstIterator& other) const;
private:
using OuterIter = Map::ConstIterator;
using InnerIter = RecordList::ConstIterator;
OuterIter m_outer_iter;
InnerIter m_inner_iter;
InnerIter m_inner_end;
OuterIter m_outer_end;
};
AllocationMap();
// Would require a deep copy of the Judy data
AllocationMap(const AllocationMap&) = delete;
// Insert a new record -- copies record
void insert(void* ptr, AllocationRecord record);
// Find a record -- throws an exception if the record is not found.
// AllocationRecord addresses will not change once registered, so
// the resulting address of a find(ptr) call can be stored
// externally until deregistered. Note also that this class
// deallocates the AllocationRecord when removed(), so the pointer
// will become invalid at that point.
const AllocationRecord* find(void* ptr) const;
AllocationRecord* find(void* ptr);
// This version of find never throws an exception
const AllocationRecord* findRecord(void* ptr) const noexcept;
AllocationRecord* findRecord(void* ptr) noexcept;
// Only allows erasing the last inserted entry for key = ptr
AllocationRecord remove(void* ptr);
// Check if a pointer has been added to the map.
bool contains(void* ptr) const;
// Clear all records from the map
void clear();
// Returns number of entries
std::size_t size() const;
// Print methods -- either matching a predicate or all records
void print(const std::function<bool (const AllocationRecord&)>&& predicate,
std::ostream& os = std::cout) const;
void printAll(std::ostream& os = std::cout) const;
ConstIterator begin() const;
ConstIterator end() const;
private:
// Content of findRecord(void*) without the lock
const AllocationRecord* doFindRecord(void* ptr) const noexcept;
// This block pool is used inside RecordList, but is needed here so its
// destruction is linked to that of AllocationMap
FixedMallocPool m_block_pool;
Map m_map;
std::size_t m_size;
mutable std::mutex m_mutex;
};
} // end of namespace util
} // end of namespace umpire
#endif // UMPIRE_AllocationMap_HPP
| 28.748634
| 102
| 0.692074
|
agcapps
|
78f3d5fb59b10214f57a97c3f539b3ff16f6abb0
| 303
|
cc
|
C++
|
src/utils/src/threads/synchronization/lock.cc
|
Kozoriz/c-plus-utils
|
b64b283aa37be9526edb229b1e01d5107f4c7c78
|
[
"MIT"
] | null | null | null |
src/utils/src/threads/synchronization/lock.cc
|
Kozoriz/c-plus-utils
|
b64b283aa37be9526edb229b1e01d5107f4c7c78
|
[
"MIT"
] | null | null | null |
src/utils/src/threads/synchronization/lock.cc
|
Kozoriz/c-plus-utils
|
b64b283aa37be9526edb229b1e01d5107f4c7c78
|
[
"MIT"
] | null | null | null |
#include "utils/threads/synchronization/lock.h"
utils::synchronization::Lock::Lock() {}
void utils::synchronization::Lock::Acquire() {
std_mutex_.lock();
}
void utils::synchronization::Lock::Release() {
std_mutex_.unlock();
}
void utils::synchronization::Lock::Try() {
std_mutex_.try_lock();
}
| 20.2
| 47
| 0.712871
|
Kozoriz
|
78f50b2420169644c1e10ec8c1fcf8bcd1f25ea5
| 5,454
|
cpp
|
C++
|
Game/FinFan/Global.cpp
|
aldonunez/FinFan_script
|
eca35c0983252cc0f1536ec15c294cd726883ca6
|
[
"Apache-2.0"
] | 4
|
2021-02-11T18:48:01.000Z
|
2021-12-02T18:12:50.000Z
|
Game/FinFan/Global.cpp
|
aldonunez/FinFan_script
|
eca35c0983252cc0f1536ec15c294cd726883ca6
|
[
"Apache-2.0"
] | null | null | null |
Game/FinFan/Global.cpp
|
aldonunez/FinFan_script
|
eca35c0983252cc0f1536ec15c294cd726883ca6
|
[
"Apache-2.0"
] | 1
|
2021-02-17T23:25:44.000Z
|
2021-02-17T23:25:44.000Z
|
/*
Copyright 2012 Aldo J. Nunez
Licensed under the Apache License, Version 2.0.
See the LICENSE text file for details.
*/
#include "Common.h"
#include "Global.h"
static uint32_t timeBaseMillis;
static uint32_t runStartMillis;
int GetNextRandom( int range )
{
// The original game uses two tables of 256 random bytes with indexes for different purposes.
return rand() % range;
}
Direction GetOppositeDir( Direction direction )
{
switch ( direction )
{
case Dir_Right: return Dir_Left;
case Dir_Left: return Dir_Right;
case Dir_Down: return Dir_Up;
case Dir_Up: return Dir_Down;
default: return Dir_None;
}
}
void DecompressMap( const uint8_t* compressedCells, uint8_t* uncompressedCells )
{
for ( ; *compressedCells != 0xff; compressedCells++ )
{
if ( (int8_t) *compressedCells < 0 )
{
int tileRef = *compressedCells++ & 0x7f;
int count = *compressedCells;
if ( count == 0 )
count = 256;
for ( int i = 0; i < count; i++ )
{
*uncompressedCells++ = tileRef;
}
}
else
{
*uncompressedCells++ = *compressedCells;
}
}
}
bool LoadResource( const char* filename, ResourceLoader* loader )
{
FILE* file = nullptr;
errno_t err = fopen_s( &file, filename, "rb" );
if ( err != 0 )
return false;
fseek( file, 0, SEEK_END );
int fileSize = ftell( file );
fseek( file, 0, SEEK_SET );
if ( !loader->Load( file, fileSize ) )
return false;
fclose( file );
return true;
}
struct ColorInt24
{
uint8_t Blue;
uint8_t Green;
uint8_t Red;
};
uint8_t Global::domains[Domains][DomainFormations];
uint8_t Global::formationWeights[FormationWeights];
uint16_t Global::prices[Prices];
static ColorInt24 nesColors[64];
bool Global::Init()
{
if ( !LoadList( "domains.dat", domains, Domains ) )
return false;
if ( !LoadList( "formationWeights.dat", formationWeights, FormationWeights ) )
return false;
if ( !LoadList( "prices.dat", prices, Prices ) )
return false;
if ( !LoadList( "nesColors.dat", nesColors, _countof( nesColors ) ) )
return false;
return true;
}
ALLEGRO_COLOR Global::GetSystemColor( int colorIndex )
{
ColorInt24& color = nesColors[colorIndex];
return al_map_rgb( color.Red, color.Green, color.Blue );
}
int Global::GetBattleFormation( int domain )
{
int baseIndex = domain * DomainFormations;
int r = GetNextRandom( FormationWeights );
int index = formationWeights[r];
return domains[domain][index];
}
int Global::GetPrice( int itemId )
{
return prices[itemId];
}
uint32_t Global::GetTime()
{
uint32_t procMillis = al_get_time() * 1000;
uint32_t timeMillis = timeBaseMillis + (procMillis - runStartMillis);
return timeMillis;
}
void Global::SetTime( uint32_t timeMillis )
{
timeBaseMillis = timeMillis;
runStartMillis = al_get_time() * 1000;
}
void Global::GetHoursMinutes( uint32_t millis, uint32_t& hours, uint32_t& minutes )
{
uint32_t totalMinutes = millis / (1000 * 60);
hours = totalMinutes / 60;
minutes = totalMinutes - (hours * 60);
}
void Actor::AddHp( int value )
{
int hp = GetHp() + value;
if ( hp <= 0 )
{
hp = 0;
SetStatus( GetStatus() | Status_Death );
}
else if ( hp > GetMaxHp() )
{
hp = GetMaxHp();
}
SetHp( hp );
}
void Actor::AddStatus( int value )
{
SetStatus( GetStatus() | value );
if ( (value & Status_Death) != 0 )
SetHp( 0 );
if ( (value & Status_Stone) != 0
&& GetEnemyClasses() != 0 )
{
SetHp( 0 );
SetStatus( GetStatus() | Status_Death );
}
}
void Actor::RemoveStatus( int value )
{
SetStatus( GetStatus() & ~value );
}
void Actor::AddHitMultiplier( int value )
{
int multiplier = GetHitMultiplier() + value;
if ( multiplier < 0 )
multiplier = 0;
else if ( multiplier > 2 )
multiplier = 2;
SetHitMultiplier( multiplier );
}
void Actor::LowerMorale( int value )
{
int morale = GetMorale();
if ( morale < MaxMorale )
{
if ( value > morale )
morale = 0;
else
morale -= value;
SetMorale( morale );
}
// bosses have max morale and don't flee
}
void Actor::AddElementStrength( int value )
{
SetElementStrength( GetElementStrength() | value );
}
void Actor::AddAbsorb( int value )
{
int absorb = GetAbsorb() + value;
SetAbsorb( absorb );
}
void Actor::AddDamage( int value )
{
int damage = GetDamage() + value;
SetDamage( damage );
}
void Actor::AddHitRate( int value )
{
int hitRate = GetHitRate() + value;
SetHitRate( hitRate );
}
void Actor::AddEvadeRate( int value )
{
int EvadeRate = GetEvadeRate() + value;
SetEvadeRate( EvadeRate );
}
bool Actor::IsAlive()
{
return GetHp() > 0
&& (GetStatus() & Status_Death) == 0
&& (GetStatus() & Status_Stone) == 0;
}
bool Actor::IsStrictlyAlive()
{
return GetHp() > 0
&& (GetStatus() & Status_Death) == 0;
}
| 21.816
| 98
| 0.578291
|
aldonunez
|
78fd211db23fcdf4a7537954bac3d1e94b949bf2
| 37,857
|
cpp
|
C++
|
media_driver/media_driver_next/linux/common/os/mos_graphicsresource_specific_next.cpp
|
Alex1Zhang/media-driver
|
b285f47f1fb127cc3ca4f677631b6a71321a2db4
|
[
"MIT",
"Intel",
"BSD-3-Clause"
] | 6
|
2019-04-18T02:51:40.000Z
|
2021-07-07T01:32:26.000Z
|
media_driver/media_driver_next/linux/common/os/mos_graphicsresource_specific_next.cpp
|
sushma08/media-driver
|
2eeb7e50604232e9a67fef0301adb4af108faccd
|
[
"Intel",
"BSD-3-Clause",
"MIT"
] | 2
|
2019-04-12T03:00:14.000Z
|
2019-10-17T06:01:19.000Z
|
media_driver/media_driver_next/linux/common/os/mos_graphicsresource_specific_next.cpp
|
yangnin/media-driver
|
2c12eac7bdd5bb5ab97c740c9ad66cfaa9ba23be
|
[
"MIT",
"Intel",
"BSD-3-Clause"
] | 6
|
2018-12-20T06:39:59.000Z
|
2019-09-25T06:24:02.000Z
|
/*
* Copyright (c) 2019-2020, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file mos_graphicsresource_specific_next.cpp
//! \brief Container class for the linux/Android specfic graphic resource
//!
#include "mos_defs.h"
#include "mos_util_debug_next.h"
#include "mos_graphicsresource_specific_next.h"
#include "mos_context_specific_next.h"
#include "mos_os_specific_next.h"
#include "memory_policy_manager.h"
GraphicsResourceSpecificNext::GraphicsResourceSpecificNext()
{
MOS_OS_FUNCTION_ENTER;
}
GraphicsResourceSpecificNext::~GraphicsResourceSpecificNext()
{
MOS_OS_FUNCTION_ENTER;
}
bool GraphicsResourceSpecificNext::ResourceIsNull()
{
return ((m_bo == nullptr)
#if (_DEBUG || _RELEASE_INTERNAL)
&& ((m_pData == nullptr) )
#endif // (_DEBUG || _RELEASE_INTERNAL)
);
}
GMM_RESOURCE_FORMAT GraphicsResourceSpecificNext::ConvertMosFmtToGmmFmt(MOS_FORMAT format)
{
switch (format)
{
case Format_Buffer : return GMM_FORMAT_GENERIC_8BIT;
case Format_Buffer_2D : return GMM_FORMAT_GENERIC_8BIT;
case Format_L8 : return GMM_FORMAT_GENERIC_8BIT;
case Format_L16 : return GMM_FORMAT_L16_UNORM_TYPE;
case Format_STMM : return GMM_FORMAT_R8_UNORM_TYPE;
case Format_AI44 : return GMM_FORMAT_GENERIC_8BIT;
case Format_IA44 : return GMM_FORMAT_GENERIC_8BIT;
case Format_R5G6B5 : return GMM_FORMAT_B5G6R5_UNORM_TYPE;
case Format_X8R8G8B8 : return GMM_FORMAT_B8G8R8X8_UNORM_TYPE;
case Format_A8R8G8B8 : return GMM_FORMAT_B8G8R8A8_UNORM_TYPE;
case Format_X8B8G8R8 : return GMM_FORMAT_R8G8B8X8_UNORM_TYPE;
case Format_A8B8G8R8 : return GMM_FORMAT_R8G8B8A8_UNORM_TYPE;
case Format_R32F : return GMM_FORMAT_R32_FLOAT_TYPE;
case Format_V8U8 : return GMM_FORMAT_GENERIC_16BIT; // matching size as format
case Format_YUY2 : return GMM_FORMAT_YUY2;
case Format_UYVY : return GMM_FORMAT_UYVY;
case Format_P8 : return GMM_FORMAT_RENDER_8BIT_TYPE; // matching size as format
case Format_A8 : return GMM_FORMAT_A8_UNORM_TYPE;
case Format_AYUV : return GMM_FORMAT_R8G8B8A8_UINT_TYPE;
case Format_NV12 : return GMM_FORMAT_NV12_TYPE;
case Format_NV21 : return GMM_FORMAT_NV21_TYPE;
case Format_YV12 : return GMM_FORMAT_YV12_TYPE;
case Format_R32U : return GMM_FORMAT_R32_UINT_TYPE;
case Format_R32S : return GMM_FORMAT_R32_SINT_TYPE;
case Format_RAW : return GMM_FORMAT_GENERIC_8BIT;
case Format_444P : return GMM_FORMAT_MFX_JPEG_YUV444_TYPE;
case Format_422H : return GMM_FORMAT_MFX_JPEG_YUV422H_TYPE;
case Format_422V : return GMM_FORMAT_MFX_JPEG_YUV422V_TYPE;
case Format_IMC3 : return GMM_FORMAT_IMC3_TYPE;
case Format_411P : return GMM_FORMAT_MFX_JPEG_YUV411_TYPE;
case Format_411R : return GMM_FORMAT_MFX_JPEG_YUV411R_TYPE;
case Format_RGBP : return GMM_FORMAT_RGBP_TYPE;
case Format_BGRP : return GMM_FORMAT_BGRP_TYPE;
case Format_R8U : return GMM_FORMAT_R8_UINT_TYPE;
case Format_R8UN : return GMM_FORMAT_R8_UNORM;
case Format_R16U : return GMM_FORMAT_R16_UINT_TYPE;
case Format_R16F : return GMM_FORMAT_R16_FLOAT_TYPE;
case Format_P010 : return GMM_FORMAT_P010_TYPE;
case Format_P016 : return GMM_FORMAT_P016_TYPE;
case Format_Y216 : return GMM_FORMAT_Y216_TYPE;
case Format_Y416 : return GMM_FORMAT_Y416_TYPE;
case Format_P208 : return GMM_FORMAT_P208_TYPE;
case Format_A16B16G16R16: return GMM_FORMAT_R16G16B16A16_UNORM_TYPE;
case Format_Y210 : return GMM_FORMAT_Y210_TYPE;
case Format_Y410 : return GMM_FORMAT_Y410_TYPE;
case Format_R10G10B10A2 : return GMM_FORMAT_R10G10B10A2_UNORM_TYPE;
case Format_A16B16G16R16F: return GMM_FORMAT_R16G16B16A16_FLOAT;
case Format_R32G32B32A32F: return GMM_FORMAT_R32G32B32A32_FLOAT;
default : return GMM_FORMAT_INVALID;
}
}
MOS_STATUS GraphicsResourceSpecificNext::Allocate(OsContextNext* osContextPtr, CreateParams& params)
{
MOS_OS_FUNCTION_ENTER;
if (osContextPtr == nullptr)
{
MOS_OS_ASSERTMESSAGE("Unable to get the active OS context.");
return MOS_STATUS_INVALID_HANDLE;
}
if (osContextPtr->GetOsContextValid() == false)
{
MOS_OS_ASSERTMESSAGE("The OS context got is not valid.");
return MOS_STATUS_INVALID_HANDLE;
}
OsContextSpecificNext *pOsContextSpecific = static_cast<OsContextSpecificNext *>(osContextPtr);
if (pOsContextSpecific == nullptr)
{
MOS_OS_ASSERTMESSAGE("Convert OsContextSpecific failed.");
return MOS_STATUS_INVALID_HANDLE;
}
MOS_STATUS status = MOS_STATUS_SUCCESS;
uint32_t tileFormatLinux = I915_TILING_NONE;
uint32_t alignedHeight = params.m_height;
uint32_t bufHeight = params.m_height;
GMM_RESOURCE_TYPE resourceType = RESOURCE_2D;
int32_t mem_type = MOS_MEMPOOL_VIDEOMEMORY;
GMM_RESCREATE_PARAMS gmmParams;
MosUtilities::MosZeroMemory(&gmmParams, sizeof(gmmParams));
switch (params.m_type)
{
case MOS_GFXRES_BUFFER:
case MOS_GFXRES_SCRATCH:
gmmParams.Type = RESOURCE_BUFFER;
gmmParams.Flags.Gpu.State = true;
alignedHeight = 1;
break;
case MOS_GFXRES_2D:
gmmParams.Type = RESOURCE_2D;
gmmParams.Flags.Gpu.Video = true;
break;
case MOS_GFXRES_VOLUME:
gmmParams.Type = RESOURCE_3D;
gmmParams.Flags.Gpu.Video = true;
gmmParams.Depth = params.m_depth;
break;
default:
MOS_OS_ASSERTMESSAGE("Unknown surface type");
return MOS_STATUS_UNKNOWN;
}
// Create GmmResourceInfo
gmmParams.Format = ConvertMosFmtToGmmFmt(params.m_format);
if (gmmParams.Format == GMM_FORMAT_INVALID)
{
MOS_OS_ASSERTMESSAGE("Unsupported format");
return MOS_STATUS_UNIMPLEMENTED;
}
gmmParams.BaseWidth = params.m_width;
gmmParams.BaseHeight = alignedHeight;
gmmParams.ArraySize = 1;
MOS_TILE_TYPE tileformat = params.m_tileType;
switch (tileformat)
{
case MOS_TILE_Y:
gmmParams.Flags.Gpu.MMC = params.m_isCompressible;
tileFormatLinux = I915_TILING_Y;
if (params.m_isCompressible && MEDIA_IS_SKU(pOsContextSpecific->GetSkuTable(), FtrE2ECompression))
{
gmmParams.Flags.Info.MediaCompressed = 1;
gmmParams.Flags.Gpu.CCS = 1;
gmmParams.Flags.Gpu.UnifiedAuxSurface = 1;
gmmParams.Flags.Gpu.RenderTarget = 1;
if(MEDIA_IS_SKU(pOsContextSpecific->GetSkuTable(), FtrFlatPhysCCS))
{
gmmParams.Flags.Gpu.UnifiedAuxSurface = 0;
}
}
break;
case MOS_TILE_X:
gmmParams.Flags.Info.TiledX = true;
tileFormatLinux = I915_TILING_X;
break;
default:
gmmParams.Flags.Info.Linear = true;
tileFormatLinux = I915_TILING_NONE;
}
if (nullptr != params.m_pSystemMemory)
{
// If user provides a system memory pointer, the gfx resource is backed
// by the system memory pages. The resource is required to be linear.
gmmParams.Flags.Info.Linear = true;
gmmParams.Flags.Info.Cacheable = true;
gmmParams.NoGfxMemory = true;
GMM_RESOURCE_INFO *tmpGmmResInfoPtr = pOsContextSpecific
->GetGmmClientContext()->CreateResInfoObject(&gmmParams);
if (tmpGmmResInfoPtr == nullptr)
{
MOS_OS_ASSERTMESSAGE("Create GmmResInfo failed");
return MOS_STATUS_UNKNOWN;
}
gmmParams.ExistingSysMemSize = GFX_ULONG_CAST(tmpGmmResInfoPtr->GetSizeSurface());
gmmParams.pExistingSysMem = (GMM_VOIDPTR64)params.m_pSystemMemory;
gmmParams.NoGfxMemory = false;
gmmParams.Flags.Info.ExistingSysMem = true;
pOsContextSpecific->GetGmmClientContext()
->DestroyResInfoObject(tmpGmmResInfoPtr);
}
else
{
gmmParams.Flags.Info.LocalOnly = MEDIA_IS_SKU(pOsContextSpecific->GetSkuTable(), FtrLocalMemory);
}
GMM_RESOURCE_INFO* gmmResourceInfoPtr = pOsContextSpecific->GetGmmClientContext()->CreateResInfoObject(&gmmParams);
if (gmmResourceInfoPtr == nullptr)
{
MOS_OS_ASSERTMESSAGE("Get gmmResourceInfoPtr failed.");
return MOS_STATUS_INVALID_PARAMETER;
}
switch (gmmResourceInfoPtr->GetTileType())
{
case GMM_TILED_X:
tileformat = MOS_TILE_X;
tileFormatLinux = I915_TILING_X;
break;
case GMM_TILED_Y:
tileformat = MOS_TILE_Y;
tileFormatLinux = I915_TILING_Y;
break;
case GMM_NOT_TILED:
tileformat = MOS_TILE_LINEAR;
tileFormatLinux = I915_TILING_NONE;
break;
default:
tileformat = MOS_TILE_Y;
tileFormatLinux = I915_TILING_Y;
break;
}
if (params.m_tileType== MOS_TILE_Y)
{
gmmResourceInfoPtr->SetMmcMode((GMM_RESOURCE_MMC_INFO)params.m_compressionMode, 0);
}
if(!params.m_pSystemMemory)
{
MemoryPolicyParameter memPolicyPar;
MOS_ZeroMemory(&memPolicyPar, sizeof(MemoryPolicyParameter));
memPolicyPar.skuTable = pOsContextSpecific->GetSkuTable();
memPolicyPar.waTable = pOsContextSpecific->GetWaTable();
memPolicyPar.resInfo = gmmResourceInfoPtr;
memPolicyPar.resName = params.m_name.c_str();
memPolicyPar.preferredMemType = params.m_memType;
mem_type = MemoryPolicyManager::UpdateMemoryPolicy(&memPolicyPar);
}
uint32_t bufPitch = GFX_ULONG_CAST(gmmResourceInfoPtr->GetRenderPitch());
uint32_t bufSize = GFX_ULONG_CAST(gmmResourceInfoPtr->GetSizeSurface());
bufHeight = gmmResourceInfoPtr->GetBaseHeight();
unsigned long linuxPitch = 0;
MOS_LINUX_BO* boPtr = nullptr;
char bufName[m_maxBufNameLength];
MosUtilities::MosSecureStrcpy(bufName, m_maxBufNameLength, params.m_name.c_str());
MOS_TraceEventExt(EVENT_RESOURCE_ALLOCATE, EVENT_TYPE_START, nullptr, 0, nullptr, 0);
if (nullptr != params.m_pSystemMemory)
{
boPtr = mos_bo_alloc_userptr(pOsContextSpecific->m_bufmgr,
bufName,
params.m_pSystemMemory,
tileFormatLinux,
bufPitch,
bufSize,
0);
}
// Only Linear and Y TILE supported
else if (tileFormatLinux == I915_TILING_NONE)
{
boPtr = mos_bo_alloc(pOsContextSpecific->m_bufmgr, bufName, bufSize, 4096, mem_type);
}
else
{
boPtr = mos_bo_alloc_tiled(pOsContextSpecific->m_bufmgr,
bufName,
bufPitch,
bufSize/bufPitch,
1,
&tileFormatLinux,
&linuxPitch,
0,
mem_type);
bufPitch = (uint32_t)linuxPitch;
}
m_mapped = false;
if (boPtr)
{
m_format = params.m_format;
m_width = params.m_width;
m_height = bufHeight;
m_pitch = bufPitch;
m_count = 0;
m_bo = boPtr;
m_name = params.m_name;
m_pData = (uint8_t*) boPtr->virt;
m_gmmResInfo = gmmResourceInfoPtr;
m_mapped = false;
m_mmapOperation = MOS_MMAP_OPERATION_NONE;
m_arraySize = 1;
m_depth = MOS_MAX(1, gmmResourceInfoPtr->GetBaseDepth());
m_size = (uint32_t)gmmResourceInfoPtr->GetSizeSurface();
m_tileType = tileformat;
m_tileModeGMM = (MOS_TILE_MODE_GMM)gmmResourceInfoPtr->GetTileModeSurfaceState();
m_isGMMTileEnabled = true;
m_compressible = gmmParams.Flags.Gpu.MMC ?
(gmmResourceInfoPtr->GetMmcHint(0) == GMM_MMC_HINT_ON) : false;
m_isCompressed = gmmResourceInfoPtr->IsMediaMemoryCompressed(0);
m_compressionMode = (MOS_RESOURCE_MMC_MODE)gmmResourceInfoPtr->GetMmcMode(0);
MOS_OS_VERBOSEMESSAGE("Alloc %7d bytes (%d x %d resource).",bufSize, params.m_width, bufHeight);
struct {
uint32_t m_handle;
uint32_t m_resFormat;
uint32_t m_baseWidth;
uint32_t m_baseHeight;
uint32_t m_pitch;
uint32_t m_size;
uint32_t m_resTileType;
GMM_RESOURCE_FLAG m_resFlag;
uint32_t m_reserve;
} eventData;
eventData.m_handle = boPtr->handle;
eventData.m_baseWidth = m_width;
eventData.m_baseHeight = m_height;
eventData.m_pitch = m_pitch;
eventData.m_size = m_size;
eventData.m_resFormat = m_format;
eventData.m_resTileType = m_tileType;
eventData.m_resFlag = gmmResourceInfoPtr->GetResFlags();
eventData.m_reserve = 0;
MOS_TraceEventExt(EVENT_RESOURCE_ALLOCATE,
EVENT_TYPE_INFO,
&eventData,
sizeof(eventData),
params.m_name.c_str(),
params.m_name.size() + 1);
}
else
{
MOS_OS_ASSERTMESSAGE("Fail to Alloc %7d bytes (%d x %d resource).",bufSize, params.m_width, params.m_height);
status = MOS_STATUS_NO_SPACE;
}
MOS_TraceEventExt(EVENT_RESOURCE_ALLOCATE, EVENT_TYPE_END, &status, sizeof(status), nullptr, 0);
m_memAllocCounterGfx++;
return status;
}
void GraphicsResourceSpecificNext::Free(OsContextNext* osContextPtr, uint32_t freeFlag)
{
MOS_OS_FUNCTION_ENTER;
MOS_UNUSED(osContextPtr);
MOS_UNUSED(freeFlag);
OsContextSpecificNext *pOsContextSpecific = static_cast<OsContextSpecificNext *>(osContextPtr);
MOS_LINUX_BO* boPtr = m_bo;
if (boPtr)
{
AuxTableMgr *auxTableMgr = pOsContextSpecific->GetAuxTableMgr();
if (auxTableMgr)
{
auxTableMgr->UnmapResource(m_gmmResInfo, boPtr);
}
mos_bo_unreference(boPtr);
m_bo = nullptr;
if (nullptr != m_gmmResInfo)
{
pOsContextSpecific->GetGmmClientContext()->DestroyResInfoObject(m_gmmResInfo);
m_gmmResInfo = nullptr;
m_memAllocCounterGfx--;
}
}
return;
}
bool GraphicsResourceSpecificNext::IsEqual(GraphicsResourceNext* toCompare)
{
if (toCompare == nullptr)
{
return false;
}
GraphicsResourceSpecificNext *resSpecificPtr = static_cast<GraphicsResourceSpecificNext *>(toCompare);
return (m_bo == resSpecificPtr->m_bo);
}
bool GraphicsResourceSpecificNext::IsValid()
{
return (m_bo != nullptr);
}
MOS_STATUS GraphicsResourceSpecificNext::ConvertToMosResource(MOS_RESOURCE* pMosResource)
{
if (pMosResource == nullptr)
{
return MOS_STATUS_INVALID_PARAMETER;
}
pMosResource->Format = m_format;
pMosResource->iWidth = m_width;
pMosResource->iHeight = m_height;
pMosResource->iPitch = m_pitch;
pMosResource->iDepth = m_depth;
pMosResource->TileType = m_tileType;
pMosResource->TileModeGMM = m_tileModeGMM;
pMosResource->bGMMTileEnabled = m_isGMMTileEnabled;
pMosResource->iCount = 0;
pMosResource->pData = m_pData;
pMosResource->bufname = m_name.c_str();
pMosResource->bo = m_bo;
pMosResource->bMapped = m_mapped;
pMosResource->MmapOperation = m_mmapOperation;
pMosResource->pGmmResInfo = m_gmmResInfo;
pMosResource->user_provided_va = m_userProvidedVA;
pMosResource->pGfxResourceNext = this;
return MOS_STATUS_SUCCESS;
}
void* GraphicsResourceSpecificNext::Lock(OsContextNext* osContextPtr, LockParams& params)
{
MOS_OS_FUNCTION_ENTER;
if (osContextPtr == nullptr)
{
MOS_OS_ASSERTMESSAGE("Unable to get the active OS context.");
return nullptr;
}
if (osContextPtr ->GetOsContextValid() == false)
{
MOS_OS_ASSERTMESSAGE("The OS context got is not valid.");
return nullptr;
}
OsContextSpecificNext *pOsContextSpecific = static_cast<OsContextSpecificNext *>(osContextPtr);
void* dataPtr = nullptr;
MOS_LINUX_BO* boPtr = m_bo;
if (boPtr)
{
// Do decompression for a compressed surface before lock
const auto pGmmResInfo = m_gmmResInfo;
MOS_OS_ASSERT(pGmmResInfo);
GMM_RESOURCE_FLAG GmmFlags = pGmmResInfo->GetResFlags();
if (!params.m_noDecompress &&
(((GmmFlags.Gpu.MMC || GmmFlags.Gpu.CCS) && GmmFlags.Info.MediaCompressed) ||
pGmmResInfo->IsMediaMemoryCompressed(0)))
{
MOS_RESOURCE mosResource = {};
ConvertToMosResource(&mosResource);
MosDecompression *mosDecompression = pOsContextSpecific->GetMosDecompression();
if (nullptr == mosDecompression)
{
MOS_OS_ASSERTMESSAGE("mosDecompression is NULL.");
return nullptr;
}
mosDecompression->MemoryDecompress(&mosResource);
}
if(false == m_mapped)
{
if (pOsContextSpecific->IsAtomSoc())
{
mos_gem_bo_map_gtt(boPtr);
}
else
{
if (m_tileType != MOS_TILE_LINEAR && !params.m_tileAsTiled)
{
if (pOsContextSpecific->UseSwSwizzling())
{
mos_bo_map(boPtr, ( OSKM_LOCKFLAG_WRITEONLY & params.m_writeRequest ));
m_mmapOperation = MOS_MMAP_OPERATION_MMAP;
if (m_systemShadow == nullptr)
{
m_systemShadow = (uint8_t *)MOS_AllocMemory(boPtr->size);
MOS_OS_CHECK_CONDITION((m_systemShadow == nullptr), "Failed to allocate shadow surface", nullptr);
}
if (m_systemShadow)
{
int32_t flags = pOsContextSpecific->GetTileYFlag() ? 0 : 1;
uint64_t surfSize = m_gmmResInfo->GetSizeMainSurface();
MOS_OS_CHECK_CONDITION((m_tileType != MOS_TILE_Y), "Unsupported tile type", nullptr);
MOS_OS_CHECK_CONDITION((boPtr->size <= 0 || m_pitch <= 0), "Invalid BO size or pitch", nullptr);
MosUtilities::MosSwizzleData((uint8_t*)boPtr->virt, m_systemShadow,
MOS_TILE_Y, MOS_TILE_LINEAR,
(int32_t)(surfSize / m_pitch), m_pitch, flags);
}
}
else
{
mos_gem_bo_map_gtt(boPtr);
m_mmapOperation = MOS_MMAP_OPERATION_MMAP_GTT;
}
}
else if (params.m_uncached)
{
mos_gem_bo_map_wc(boPtr);
m_mmapOperation = MOS_MMAP_OPERATION_MMAP_WC;
}
else
{
mos_bo_map(boPtr, ( OSKM_LOCKFLAG_WRITEONLY & params.m_writeRequest ));
m_mmapOperation = MOS_MMAP_OPERATION_MMAP;
}
}
m_mapped = true;
m_pData = m_systemShadow ? m_systemShadow : (uint8_t *)boPtr->virt;
}
dataPtr = m_pData;
}
MOS_OS_ASSERT(dataPtr);
return dataPtr;
}
MOS_STATUS GraphicsResourceSpecificNext::Unlock(OsContextNext* osContextPtr)
{
MOS_OS_FUNCTION_ENTER;
if (osContextPtr == nullptr)
{
MOS_OS_ASSERTMESSAGE("Unable to get the active OS context.");
return MOS_STATUS_INVALID_HANDLE;
}
if (osContextPtr ->GetOsContextValid() == false)
{
MOS_OS_ASSERTMESSAGE("The OS context got is not valid.");
return MOS_STATUS_INVALID_HANDLE;
}
OsContextSpecificNext *pOsContextSpecific = static_cast<OsContextSpecificNext *>(osContextPtr);
MOS_LINUX_BO* boPtr = m_bo;
if (boPtr)
{
if (m_mapped)
{
if (pOsContextSpecific->IsAtomSoc())
{
mos_gem_bo_unmap_gtt(boPtr);
}
else
{
if (m_systemShadow)
{
int32_t flags = pOsContextSpecific->GetTileYFlag() ? 0 : 1;
uint64_t surfSize = m_gmmResInfo->GetSizeMainSurface();
MosUtilities::MosSwizzleData(m_systemShadow, (uint8_t*)boPtr->virt,
MOS_TILE_LINEAR, MOS_TILE_Y,
(int32_t)(surfSize / m_pitch), m_pitch, flags);
MOS_FreeMemory(m_systemShadow);
m_systemShadow = nullptr;
}
switch(m_mmapOperation)
{
case MOS_MMAP_OPERATION_MMAP_GTT:
mos_gem_bo_unmap_gtt(boPtr);
break;
case MOS_MMAP_OPERATION_MMAP_WC:
mos_gem_bo_unmap_wc(boPtr);
break;
case MOS_MMAP_OPERATION_MMAP:
mos_bo_unmap(boPtr);
break;
default:
MOS_OS_ASSERTMESSAGE("Invalid mmap operation type");
break;
}
}
m_mapped = false;
m_mmapOperation = MOS_MMAP_OPERATION_NONE;
boPtr->virt = nullptr;
m_bo = boPtr;
}
m_pData = nullptr;
}
return MOS_STATUS_SUCCESS;
}
MOS_STATUS GraphicsResourceSpecificNext::AllocateExternalResource(
MOS_STREAM_HANDLE streamState,
PMOS_ALLOC_GFXRES_PARAMS params,
MOS_RESOURCE_HANDLE& resource)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
const char *bufname = params->pBufName;;
int32_t iSize = 0;
int32_t iPitch = 0;
unsigned long ulPitch = 0;
MOS_LINUX_BO *bo = nullptr;
MOS_TILE_TYPE tileformat = params->TileType;
uint32_t tileformat_linux = I915_TILING_NONE;
int32_t iHeight = params->dwHeight;
int32_t iAlignedHeight = 0;
GMM_RESCREATE_PARAMS gmmParams;
GMM_RESOURCE_INFO *gmmResourceInfo = nullptr;
GMM_RESOURCE_TYPE resourceType = RESOURCE_2D;
MosUtilities::MosZeroMemory(&gmmParams, sizeof(gmmParams));
MOS_OS_CHK_NULL_RETURN(streamState->perStreamParameters);
auto perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
if (nullptr == perStreamParameters)
{
MOS_OS_ASSERTMESSAGE("input parameter perStreamParameters is NULL.");
return MOS_STATUS_INVALID_PARAMETER;
}
switch (params->Format)
{
case Format_Buffer:
case Format_RAW:
resourceType = RESOURCE_BUFFER;
iAlignedHeight = 1;
//indicate buffer Restriction is Vertex.
gmmParams.Flags.Gpu.State = true;
break;
case Format_L8:
case Format_L16:
case Format_STMM:
case Format_AI44:
case Format_IA44:
case Format_R5G6B5:
case Format_R8G8B8:
case Format_X8R8G8B8:
case Format_A8R8G8B8:
case Format_X8B8G8R8:
case Format_A8B8G8R8:
case Format_R32S:
case Format_R32F:
case Format_V8U8:
case Format_YUY2:
case Format_UYVY:
case Format_P8:
case Format_A8:
case Format_AYUV:
case Format_NV12:
case Format_NV21:
case Format_YV12:
case Format_Buffer_2D:
case Format_R32U:
case Format_444P:
case Format_422H:
case Format_422V:
case Format_IMC3:
case Format_411P:
case Format_411R:
case Format_RGBP:
case Format_BGRP:
case Format_R16U:
case Format_R8U:
case Format_R8UN:
case Format_P010:
case Format_P016:
case Format_Y216:
case Format_Y416:
case Format_P208:
case Format_Y210:
case Format_Y410:
case Format_R16F:
resourceType = RESOURCE_2D;
//indicate buffer Restriction is Planar surface restrictions.
gmmParams.Flags.Gpu.Video = true;
break;
default:
MOS_OS_ASSERTMESSAGE("Unsupported format");
eStatus = MOS_STATUS_UNIMPLEMENTED;
return eStatus;
}
// Create GmmResourceInfo
gmmParams.BaseWidth = params->dwWidth;
gmmParams.BaseHeight = iAlignedHeight;
gmmParams.ArraySize = 1;
gmmParams.Type = resourceType;
gmmParams.Format = MosOsSpecificNext::Mos_Specific_ConvertMosFmtToGmmFmt(params->Format);
MOS_OS_CHECK_CONDITION(gmmParams.Format == GMM_FORMAT_INVALID,
"Unsupported format",
MOS_STATUS_UNKNOWN);
switch (tileformat)
{
case MOS_TILE_Y:
gmmParams.Flags.Gpu.MMC = params->bIsCompressible;
tileformat_linux = I915_TILING_Y;
break;
case MOS_TILE_X:
gmmParams.Flags.Info.TiledX = true;
tileformat_linux = I915_TILING_X;
break;
default:
gmmParams.Flags.Info.Linear = true;
tileformat_linux = I915_TILING_NONE;
}
gmmParams.Flags.Info.LocalOnly = MEDIA_IS_SKU(&perStreamParameters->SkuTable, FtrLocalMemory);
resource->pGmmResInfo = gmmResourceInfo = perStreamParameters->pGmmClientContext->CreateResInfoObject(&gmmParams);
MOS_OS_CHK_NULL_RETURN(gmmResourceInfo);
switch (gmmResourceInfo->GetTileType())
{
case GMM_TILED_X:
tileformat = MOS_TILE_X;
tileformat_linux = I915_TILING_X;
break;
case GMM_TILED_Y:
tileformat = MOS_TILE_Y;
tileformat_linux = I915_TILING_Y;
break;
case GMM_NOT_TILED:
tileformat = MOS_TILE_LINEAR;
tileformat_linux = I915_TILING_NONE;
break;
default:
tileformat = MOS_TILE_Y;
tileformat_linux = I915_TILING_Y;
break;
}
if (params->TileType == MOS_TILE_Y)
{
gmmResourceInfo->SetMmcMode((GMM_RESOURCE_MMC_INFO)params->CompressionMode, 0);
}
iPitch = GFX_ULONG_CAST(gmmResourceInfo->GetRenderPitch());
iSize = GFX_ULONG_CAST(gmmResourceInfo->GetSizeSurface());
iHeight = gmmResourceInfo->GetBaseHeight();
// Only Linear and Y TILE supported
if (tileformat_linux == I915_TILING_NONE)
{
bo = mos_bo_alloc(perStreamParameters->bufmgr, bufname, iSize, 4096, MOS_MEMPOOL_VIDEOMEMORY);
}
else
{
bo = mos_bo_alloc_tiled(perStreamParameters->bufmgr,
bufname,
iPitch,
iSize / iPitch,
1,
&tileformat_linux,
&ulPitch,
0,
MOS_MEMPOOL_VIDEOMEMORY);
iPitch = (int32_t)ulPitch;
}
resource->bMapped = false;
if (bo)
{
resource->Format = params->Format;
resource->iWidth = params->dwWidth;
resource->iHeight = iHeight;
resource->iPitch = iPitch;
resource->iCount = 0;
resource->bufname = bufname;
resource->bo = bo;
resource->TileType = tileformat;
resource->TileModeGMM = (MOS_TILE_MODE_GMM)gmmResourceInfo->GetTileModeSurfaceState();
resource->bGMMTileEnabled = true;
resource->pData = (uint8_t *)bo->virt; //It is useful for batch buffer to fill commands
MOS_OS_VERBOSEMESSAGE("Alloc %7d bytes (%d x %d resource).", iSize, params->dwWidth, iHeight);
}
else
{
MOS_OS_ASSERTMESSAGE("Fail to Alloc %7d bytes (%d x %d resource).", iSize, params->dwWidth, params->dwHeight);
eStatus = MOS_STATUS_NO_SPACE;
}
return eStatus;
}
MOS_STATUS GraphicsResourceSpecificNext::FreeExternalResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
uint32_t flag)
{
MOS_OS_FUNCTION_ENTER;
MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
if (resource && resource->bo)
{
OsContextSpecificNext *osCtx = static_cast<OsContextSpecificNext *>(streamState->osDeviceContext);
if (osCtx == nullptr)
{
MOS_OS_ASSERTMESSAGE("osCtx is nullptr!");
return MOS_STATUS_NULL_POINTER;
}
else
{
AuxTableMgr *auxTableMgr = osCtx->GetAuxTableMgr();
// Unmap Resource from Aux Table
if (auxTableMgr)
{
auxTableMgr->UnmapResource(resource->pGmmResInfo, resource->bo);
}
}
mos_bo_unreference((MOS_LINUX_BO *)(resource->bo));
MOS_OS_CHK_NULL_RETURN(streamState->perStreamParameters);
auto perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
if (perStreamParameters != nullptr && perStreamParameters->contextOffsetList.size())
{
MOS_CONTEXT *pOsCtx = perStreamParameters;
auto item_ctx = pOsCtx->contextOffsetList.begin();
for (; item_ctx != pOsCtx->contextOffsetList.end();)
{
if (item_ctx->target_bo == resource->bo)
{
item_ctx = pOsCtx->contextOffsetList.erase(item_ctx);
}
else
{
item_ctx++;
}
}
}
resource->bo = nullptr;
}
return eStatus;
}
void* GraphicsResourceSpecificNext::LockExternalResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource,
PMOS_LOCK_PARAMS flags)
{
MOS_OS_FUNCTION_ENTER;
void *pData = nullptr;
if (nullptr == streamState)
{
MOS_OS_ASSERTMESSAGE("input parameter streamState is NULL.");
return nullptr;
}
if (nullptr == resource)
{
MOS_OS_ASSERTMESSAGE("input parameter resource is NULL.");
return nullptr;
}
if (streamState->perStreamParameters == nullptr)
{
MOS_OS_ASSERTMESSAGE("perStreamParameters is nullptr, skip lock");
return nullptr;
}
auto perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
if (resource && resource->bo && resource->pGmmResInfo)
{
MOS_LINUX_BO *bo = resource->bo;
GMM_RESOURCE_FLAG GmmFlags = resource->pGmmResInfo->GetResFlags();
// Do decompression for a compressed surface before lock
if (!flags->NoDecompress &&
(((GmmFlags.Gpu.MMC || GmmFlags.Gpu.CCS) && GmmFlags.Info.MediaCompressed) ||
resource->pGmmResInfo->IsMediaMemoryCompressed(0)))
{
OsContextNext *osCtx = streamState->osDeviceContext;
if (nullptr == osCtx)
{
MOS_OS_ASSERTMESSAGE("osCtx is NULL.");
return nullptr;
}
MosDecompression *mosDecompression = osCtx->GetMosDecompression();
if (nullptr == mosDecompression)
{
MOS_OS_ASSERTMESSAGE("mosDecompression is NULL.");
return nullptr;
}
mosDecompression->MemoryDecompress(resource);
}
if (false == resource->bMapped)
{
if (perStreamParameters->bIsAtomSOC)
{
mos_gem_bo_map_gtt(bo);
}
else
{
if (resource->TileType != MOS_TILE_LINEAR && !flags->TiledAsTiled)
{
if (perStreamParameters->bUseSwSwizzling)
{
mos_bo_map(bo, (OSKM_LOCKFLAG_WRITEONLY & flags->WriteOnly));
resource->MmapOperation = MOS_MMAP_OPERATION_MMAP;
if (resource->pSystemShadow == nullptr)
{
resource->pSystemShadow = (uint8_t *)MOS_AllocMemory(bo->size);
MOS_OS_CHECK_CONDITION((resource->pSystemShadow == nullptr), "Failed to allocate shadow surface", nullptr);
}
if (resource->pSystemShadow)
{
int32_t swizzleflags = perStreamParameters->bTileYFlag ? 0 : 1;
MOS_OS_CHECK_CONDITION((resource->TileType != MOS_TILE_Y), "Unsupported tile type", nullptr);
MOS_OS_CHECK_CONDITION((bo->size <= 0 || resource->iPitch <= 0), "Invalid BO size or pitch", nullptr);
MosUtilities::MosSwizzleData((uint8_t *)bo->virt, resource->pSystemShadow, MOS_TILE_Y, MOS_TILE_LINEAR, bo->size / resource->iPitch, resource->iPitch, swizzleflags);
}
}
else
{
mos_gem_bo_map_gtt(bo);
resource->MmapOperation = MOS_MMAP_OPERATION_MMAP_GTT;
}
}
else if (flags->Uncached)
{
mos_gem_bo_map_wc(bo);
resource->MmapOperation = MOS_MMAP_OPERATION_MMAP_WC;
}
else
{
mos_bo_map(bo, (OSKM_LOCKFLAG_WRITEONLY & flags->WriteOnly));
resource->MmapOperation = MOS_MMAP_OPERATION_MMAP;
}
}
resource->pData = resource->pSystemShadow ? resource->pSystemShadow : (uint8_t *)bo->virt;
resource->bMapped = true;
}
pData = resource->pData;
}
MOS_OS_ASSERT(pData);
return pData;
}
MOS_STATUS GraphicsResourceSpecificNext::UnlockExternalResource(
MOS_STREAM_HANDLE streamState,
MOS_RESOURCE_HANDLE resource)
{
MOS_OS_FUNCTION_ENTER;
MOS_OS_CHK_NULL_RETURN(resource);
MOS_OS_CHK_NULL_RETURN(streamState);
MOS_OS_CHK_NULL_RETURN(streamState->osDeviceContext);
MOS_OS_CHK_NULL_RETURN(streamState->perStreamParameters);
auto perStreamParameters = (PMOS_CONTEXT)streamState->perStreamParameters;
if (resource->bo)
{
if (true == resource->bMapped)
{
if (perStreamParameters->bIsAtomSOC)
{
mos_gem_bo_unmap_gtt(resource->bo);
}
else
{
if (resource->pSystemShadow)
{
int32_t flags = perStreamParameters->bTileYFlag ? 0 : 1;
MosUtilities::MosSwizzleData(resource->pSystemShadow, (uint8_t *)resource->bo->virt, MOS_TILE_LINEAR, MOS_TILE_Y, resource->bo->size / resource->iPitch, resource->iPitch, flags);
MOS_FreeMemory(resource->pSystemShadow);
resource->pSystemShadow = nullptr;
}
switch (resource->MmapOperation)
{
case MOS_MMAP_OPERATION_MMAP_GTT:
mos_gem_bo_unmap_gtt(resource->bo);
break;
case MOS_MMAP_OPERATION_MMAP_WC:
mos_gem_bo_unmap_wc(resource->bo);
break;
case MOS_MMAP_OPERATION_MMAP:
mos_bo_unmap(resource->bo);
break;
default:
MOS_OS_ASSERTMESSAGE("Invalid mmap operation type");
break;
}
}
resource->bo->virt = nullptr;
resource->bMapped = false;
}
resource->pData = nullptr;
}
return MOS_STATUS_SUCCESS;
}
| 35.546479
| 198
| 0.605753
|
Alex1Zhang
|
60025aa3b9b349ccacfefd74e2f9dc6bf594e3dc
| 2,081
|
cpp
|
C++
|
plugins/qm-dsp/dsp/tonal/TonalEstimator.cpp
|
horstsoft0815/qlcplus
|
249da9d165630b89fe9fbb0796d892c992645709
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
plugins/qm-dsp/dsp/tonal/TonalEstimator.cpp
|
horstsoft0815/qlcplus
|
249da9d165630b89fe9fbb0796d892c992645709
|
[
"ECL-2.0",
"Apache-2.0"
] | 8
|
2021-11-14T16:31:59.000Z
|
2021-12-11T19:53:10.000Z
|
plugins/qm-dsp/dsp/tonal/TonalEstimator.cpp
|
horstsoft0815/qlcplus
|
249da9d165630b89fe9fbb0796d892c992645709
|
[
"ECL-2.0",
"Apache-2.0"
] | null | null | null |
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
/*
QM DSP Library
Centre for Digital Music, Queen Mary, University of London.
This file copyright 2006 Martin Gasser.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version. See the file
COPYING included with this distribution for more information.
*/
#include "TonalEstimator.h"
#include <cmath>
#include <iostream>
TonalEstimator::TonalEstimator()
{
m_Basis.resize(6);
int i = 0;
// circle of fifths
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = std::sin( (7.0 / 6.0) * iP * M_PI);
}
i++;
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = std::cos( (7.0 / 6.0) * iP * M_PI);
}
i++;
// circle of major thirds
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = 0.6 * std::sin( (2.0 / 3.0) * iP * M_PI);
}
i++;
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = 0.6 * std::cos( (2.0 / 3.0) * iP * M_PI);
}
i++;
// circle of minor thirds
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = 1.1 * std::sin( (3.0 / 2.0) * iP * M_PI);
}
i++;
m_Basis[i].resize(12);
for (int iP = 0; iP < 12; iP++) {
m_Basis[i][iP] = 1.1 * std::cos( (3.0 / 2.0) * iP * M_PI);
}
}
TonalEstimator::~TonalEstimator()
{
}
TCSVector TonalEstimator::transform2TCS(const ChromaVector& rVector)
{
TCSVector vaRetVal;
vaRetVal.resize(6, 0.0);
for (int i = 0; i < 6; i++) {
for (int iP = 0; iP < 12; iP++) {
vaRetVal[i] += m_Basis[i][iP] * rVector[iP];
}
}
return vaRetVal;
}
| 22.619565
| 78
| 0.521864
|
horstsoft0815
|
60034d1aa83362c86f9a17ceb94fc8fc17325b3a
| 1,268
|
cpp
|
C++
|
options.cpp
|
kimushu/serialport-server
|
1cf84bc3adb86023f39c63940b967e830c8fe5c5
|
[
"MIT"
] | null | null | null |
options.cpp
|
kimushu/serialport-server
|
1cf84bc3adb86023f39c63940b967e830c8fe5c5
|
[
"MIT"
] | null | null | null |
options.cpp
|
kimushu/serialport-server
|
1cf84bc3adb86023f39c63940b967e830c8fe5c5
|
[
"MIT"
] | null | null | null |
#include "options.hpp"
#include <iostream>
bool Options::parse(OsPort& os, int argc, char *argv[])
{
int ch;
char *optarg = nullptr;
int optind = 0;
while ((ch = os.getopt(argc, argv, "a:p:i:m:vh", optarg, optind)) != -1)
{
switch (ch)
{
case 'a':
// -a <address>
address = optarg;
break;
case 'p':
// -p <number>
port = atoi(optarg);
break;
case 'i':
// -i <idfile>
idfile = optarg;
break;
case 'm':
// -m <number>
max_clients = atoi(optarg);
break;
case 'v':
++verbosity;
break;
case 'h':
std::cerr << "Usage: " << argv[0] << " [<options>]\n\n"
"Options:\n"
" -a <address> Specify bind address (default: 127.0.0.1)\n"
" -p <number> Specify port (default: assign an arbitrary unused port)\n"
" -i <file> Specify file to write IDs [PID:Address:Port] (default: stdout)\n"
" -m <number> Specify maximum number of clients (default: 10)\n"
" -h Print this help message\n"
<< std::endl;
return false;
default:
throw std::invalid_argument("unknown argument: " + std::string(argv[optind - 1]));
}
}
return true;
}
| 24.862745
| 94
| 0.51183
|
kimushu
|
60040cee6792901b65114f996a0dae3d82a6cb2f
| 3,243
|
cpp
|
C++
|
tests/iob_calc_test.cpp
|
beached/oref0_cpp
|
f3cc43948aeae7f857a6618588f44ace601099d6
|
[
"MIT"
] | 1
|
2016-12-18T08:58:57.000Z
|
2016-12-18T08:58:57.000Z
|
tests/iob_calc_test.cpp
|
beached/oref0_cpp
|
f3cc43948aeae7f857a6618588f44ace601099d6
|
[
"MIT"
] | null | null | null |
tests/iob_calc_test.cpp
|
beached/oref0_cpp
|
f3cc43948aeae7f857a6618588f44ace601099d6
|
[
"MIT"
] | 3
|
2016-12-18T08:59:04.000Z
|
2018-10-01T21:40:22.000Z
|
//
// Copyright (c) 2016 Darrell Wright
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files( the "Software" ), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#define BOOST_TEST_MODULE iob_calc_test
#include <boost/test/unit_test.hpp>
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <numeric>
#include <thread>
#include <vector>
#include <random>
#include <daw/json/daw_json_link.h>
#include "iob_calc.h"
struct test_data_item_t: public daw::json::JsonLink<test_data_item_t> {
ns::insulin_duration_t insulin_duration;
double time_offset;
double expected;
test_data_item_t( test_data_item_t && ) = default;
test_data_item_t & operator=( test_data_item_t && ) = default;
test_data_item_t( ns::insulin_duration_t duration, double offset, double expected_result ):
daw::json::JsonLink<test_data_item_t>{ },
insulin_duration{ duration },
time_offset{ offset },
expected{ expected_result } {
link_streamable( "insulin_duration", insulin_duration );
link_real( "time_offset", time_offset );
link_real( "expected", expected );
}
test_data_item_t( ):
test_data_item_t{ ns::insulin_duration_t::t180, 0, 1.0 } { }
}; // test_data_item_t
struct test_data_t: public daw::json::JsonLink<test_data_t> {
std::vector<test_data_item_t> tests;
test_data_t( test_data_t && other ) = default;
test_data_t & operator=( test_data_t && ) = default;
test_data_t( std::vector<test_data_item_t> Tests ):
daw::json::JsonLink<test_data_t>{ },
tests{ std::move( Tests ) } {
link_array( "tests", tests );
}
test_data_t( ):
test_data_t{ std::vector<test_data_item_t>{ } } { }
}; // test_data_t
BOOST_AUTO_TEST_CASE( insulin_on_board_pct, *boost::unit_test::tolerance( 1.0e-10 ) ) {
auto test_data = daw::json::from_file<test_data_t>( "../tests/iob_calc_test.json" );
for( auto const & test: test_data.tests ) {
auto const result = ns::insulin_on_board_pct( test.time_offset, test.insulin_duration );
std::cout << "insulin_action=" << static_cast<int>(test.insulin_duration) << " t=" << test.time_offset << std::setprecision( std::numeric_limits<double>::digits10 ) << " expected=" << test.expected << " result=" << result << " difference=" << (test.expected-result) << '\n';
BOOST_TEST( test.expected == result );
}
}
| 37.709302
| 276
| 0.731113
|
beached
|
60079244b23b0bc4aadd32f995204b72fb4de077
| 2,569
|
cc
|
C++
|
contrib/gcc-4.1/libstdc++-v3/src/stdexcept.cc
|
masami256/dfly-3.0.2-bhyve
|
6f6c18db6fa90734135a2044769035eb82b821c1
|
[
"BSD-3-Clause"
] | 3
|
2017-03-06T14:12:57.000Z
|
2019-11-23T09:35:10.000Z
|
contrib/gcc-4.1/libstdc++-v3/src/stdexcept.cc
|
masami256/dfly-3.0.2-bhyve
|
6f6c18db6fa90734135a2044769035eb82b821c1
|
[
"BSD-3-Clause"
] | null | null | null |
contrib/gcc-4.1/libstdc++-v3/src/stdexcept.cc
|
masami256/dfly-3.0.2-bhyve
|
6f6c18db6fa90734135a2044769035eb82b821c1
|
[
"BSD-3-Clause"
] | null | null | null |
// Methods for Exception Support for -*- C++ -*-
// Copyright (C) 1997, 1999, 2001, 2002 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// ISO C++ 14882: 19.1 Exception classes
//
#include <string>
#include <stdexcept>
namespace std
{
logic_error::logic_error(const string& __arg)
: exception(), _M_msg(__arg) { }
logic_error::~logic_error() throw() { }
const char*
logic_error::what() const throw()
{ return _M_msg.c_str(); }
domain_error::domain_error(const string& __arg)
: logic_error(__arg) { }
invalid_argument::invalid_argument(const string& __arg)
: logic_error(__arg) { }
length_error::length_error(const string& __arg)
: logic_error(__arg) { }
out_of_range::out_of_range(const string& __arg)
: logic_error(__arg) { }
runtime_error::runtime_error(const string& __arg)
: exception(), _M_msg(__arg) { }
runtime_error::~runtime_error() throw() { }
const char*
runtime_error::what() const throw()
{ return _M_msg.c_str(); }
range_error::range_error(const string& __arg)
: runtime_error(__arg) { }
overflow_error::overflow_error(const string& __arg)
: runtime_error(__arg) { }
underflow_error::underflow_error(const string& __arg)
: runtime_error(__arg) { }
} // namespace std
| 32.518987
| 79
| 0.72752
|
masami256
|
60088ca33cc474a4f64ad94b1e97e5089f097db0
| 495,429
|
cpp
|
C++
|
perf/collation_element_lookup_perf_000.cpp
|
eightysquirrels/text
|
d935545648777786dc196a75346cde8906da846a
|
[
"BSL-1.0"
] | null | null | null |
perf/collation_element_lookup_perf_000.cpp
|
eightysquirrels/text
|
d935545648777786dc196a75346cde8906da846a
|
[
"BSL-1.0"
] | 1
|
2021-03-05T12:56:59.000Z
|
2021-03-05T13:11:53.000Z
|
perf/collation_element_lookup_perf_000.cpp
|
eightysquirrels/text
|
d935545648777786dc196a75346cde8906da846a
|
[
"BSL-1.0"
] | 3
|
2019-10-30T18:38:15.000Z
|
2021-03-05T12:10:13.000Z
|
// Warning! This file is autogenerated.
#include <boost/text/collate.hpp>
#include <boost/text/collation_table.hpp>
#include <benchmark/benchmark.h>
boost::text::detail::collation_trie_t const & trie()
{
static auto const retval = boost::text::detail::make_default_trie();
return retval;
}
boost::text::collation_table const & table()
{
static auto const retval = boost::text::default_collation_table();
return retval;
}
uint32_t cps_000[] = {
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31
};
void BM_collation_element_lookup_000(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 0, cps_000 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 1, cps_000 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 2, cps_000 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 3, cps_000 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 4, cps_000 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 5, cps_000 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 6, cps_000 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 7, cps_000 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 8, cps_000 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 9, cps_000 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 10, cps_000 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 11, cps_000 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 12, cps_000 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 13, cps_000 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 14, cps_000 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 15, cps_000 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 16, cps_000 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 17, cps_000 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 18, cps_000 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 19, cps_000 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 20, cps_000 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 21, cps_000 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 22, cps_000 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 23, cps_000 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 24, cps_000 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 25, cps_000 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 26, cps_000 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 27, cps_000 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 28, cps_000 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 29, cps_000 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 30, cps_000 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 31, cps_000 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 32, cps_000 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 33, cps_000 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 34, cps_000 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 35, cps_000 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 36, cps_000 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 37, cps_000 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 38, cps_000 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 39, cps_000 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 40, cps_000 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 41, cps_000 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 42, cps_000 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 43, cps_000 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 44, cps_000 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 45, cps_000 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 46, cps_000 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 47, cps_000 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 48, cps_000 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_000 + 49, cps_000 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_000);
uint32_t cps_001[] = {
0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4c, 0xb7, 0x4c, 0x387, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x61
};
void BM_collation_element_lookup_001(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 0, cps_001 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 1, cps_001 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 2, cps_001 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 3, cps_001 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 4, cps_001 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 5, cps_001 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 6, cps_001 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 7, cps_001 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 8, cps_001 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 9, cps_001 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 10, cps_001 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 11, cps_001 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 12, cps_001 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 13, cps_001 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 14, cps_001 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 15, cps_001 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 16, cps_001 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 17, cps_001 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 18, cps_001 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 19, cps_001 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 20, cps_001 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 21, cps_001 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 22, cps_001 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 23, cps_001 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 24, cps_001 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 25, cps_001 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 26, cps_001 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 27, cps_001 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 29, cps_001 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 31, cps_001 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 32, cps_001 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 33, cps_001 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 34, cps_001 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 35, cps_001 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 36, cps_001 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 37, cps_001 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 38, cps_001 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 39, cps_001 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 40, cps_001 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 41, cps_001 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 42, cps_001 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 43, cps_001 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 44, cps_001 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 45, cps_001 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 46, cps_001 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 47, cps_001 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 48, cps_001 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 49, cps_001 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 50, cps_001 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_001 + 51, cps_001 + 52));
}
}
BENCHMARK(BM_collation_element_lookup_001);
uint32_t cps_002[] = {
0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6c, 0xb7, 0x6c, 0x387, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91
};
void BM_collation_element_lookup_002(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 0, cps_002 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 1, cps_002 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 2, cps_002 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 3, cps_002 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 4, cps_002 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 5, cps_002 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 6, cps_002 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 7, cps_002 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 8, cps_002 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 9, cps_002 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 10, cps_002 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 11, cps_002 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 13, cps_002 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 15, cps_002 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 16, cps_002 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 17, cps_002 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 18, cps_002 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 19, cps_002 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 20, cps_002 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 21, cps_002 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 22, cps_002 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 23, cps_002 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 24, cps_002 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 25, cps_002 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 26, cps_002 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 27, cps_002 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 28, cps_002 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 29, cps_002 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 30, cps_002 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 31, cps_002 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 32, cps_002 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 33, cps_002 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 34, cps_002 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 35, cps_002 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 36, cps_002 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 37, cps_002 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 38, cps_002 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 39, cps_002 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 40, cps_002 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 41, cps_002 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 42, cps_002 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 43, cps_002 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 44, cps_002 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 45, cps_002 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 46, cps_002 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 47, cps_002 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 48, cps_002 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 49, cps_002 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 50, cps_002 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_002 + 51, cps_002 + 52));
}
}
BENCHMARK(BM_collation_element_lookup_002);
uint32_t cps_003[] = {
0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3
};
void BM_collation_element_lookup_003(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 0, cps_003 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 1, cps_003 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 2, cps_003 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 3, cps_003 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 4, cps_003 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 5, cps_003 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 6, cps_003 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 7, cps_003 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 8, cps_003 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 9, cps_003 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 10, cps_003 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 11, cps_003 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 12, cps_003 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 13, cps_003 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 14, cps_003 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 15, cps_003 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 16, cps_003 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 17, cps_003 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 18, cps_003 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 19, cps_003 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 20, cps_003 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 21, cps_003 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 22, cps_003 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 23, cps_003 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 24, cps_003 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 25, cps_003 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 26, cps_003 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 27, cps_003 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 28, cps_003 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 29, cps_003 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 30, cps_003 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 31, cps_003 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 32, cps_003 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 33, cps_003 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 34, cps_003 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 35, cps_003 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 36, cps_003 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 37, cps_003 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 38, cps_003 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 39, cps_003 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 40, cps_003 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 41, cps_003 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 42, cps_003 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 43, cps_003 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 44, cps_003 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 45, cps_003 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 46, cps_003 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 47, cps_003 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 48, cps_003 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_003 + 49, cps_003 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_003);
uint32_t cps_004[] = {
0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5
};
void BM_collation_element_lookup_004(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 0, cps_004 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 1, cps_004 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 2, cps_004 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 3, cps_004 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 4, cps_004 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 5, cps_004 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 6, cps_004 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 7, cps_004 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 8, cps_004 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 9, cps_004 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 10, cps_004 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 11, cps_004 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 12, cps_004 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 13, cps_004 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 14, cps_004 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 15, cps_004 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 16, cps_004 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 17, cps_004 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 18, cps_004 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 19, cps_004 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 20, cps_004 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 21, cps_004 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 22, cps_004 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 23, cps_004 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 24, cps_004 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 25, cps_004 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 26, cps_004 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 27, cps_004 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 28, cps_004 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 29, cps_004 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 30, cps_004 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 31, cps_004 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 32, cps_004 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 33, cps_004 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 34, cps_004 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 35, cps_004 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 36, cps_004 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 37, cps_004 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 38, cps_004 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 39, cps_004 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 40, cps_004 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 41, cps_004 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 42, cps_004 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 43, cps_004 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 44, cps_004 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 45, cps_004 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 46, cps_004 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 47, cps_004 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 48, cps_004 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_004 + 49, cps_004 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_004);
uint32_t cps_005[] = {
0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107, 0x108, 0x109, 0x10a, 0x10b, 0x10c, 0x10d, 0x10e, 0x10f, 0x110, 0x111, 0x112, 0x113, 0x114, 0x115, 0x116, 0x117, 0x118, 0x119, 0x11a, 0x11b, 0x11c, 0x11d, 0x11e, 0x11f, 0x120, 0x121, 0x122, 0x123, 0x124, 0x125, 0x126, 0x127
};
void BM_collation_element_lookup_005(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 0, cps_005 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 1, cps_005 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 2, cps_005 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 3, cps_005 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 4, cps_005 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 5, cps_005 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 6, cps_005 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 7, cps_005 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 8, cps_005 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 9, cps_005 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 10, cps_005 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 11, cps_005 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 12, cps_005 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 13, cps_005 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 14, cps_005 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 15, cps_005 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 16, cps_005 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 17, cps_005 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 18, cps_005 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 19, cps_005 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 20, cps_005 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 21, cps_005 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 22, cps_005 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 23, cps_005 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 24, cps_005 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 25, cps_005 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 26, cps_005 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 27, cps_005 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 28, cps_005 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 29, cps_005 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 30, cps_005 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 31, cps_005 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 32, cps_005 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 33, cps_005 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 34, cps_005 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 35, cps_005 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 36, cps_005 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 37, cps_005 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 38, cps_005 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 39, cps_005 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 40, cps_005 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 41, cps_005 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 42, cps_005 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 43, cps_005 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 44, cps_005 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 45, cps_005 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 46, cps_005 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 47, cps_005 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 48, cps_005 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_005 + 49, cps_005 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_005);
uint32_t cps_006[] = {
0x128, 0x129, 0x12a, 0x12b, 0x12c, 0x12d, 0x12e, 0x12f, 0x130, 0x131, 0x132, 0x133, 0x134, 0x135, 0x136, 0x137, 0x138, 0x139, 0x13a, 0x13b, 0x13c, 0x13d, 0x13e, 0x13f, 0x140, 0x141, 0x142, 0x143, 0x144, 0x145, 0x146, 0x147, 0x148, 0x149, 0x14a, 0x14b, 0x14c, 0x14d, 0x14e, 0x14f, 0x150, 0x151, 0x152, 0x153, 0x154, 0x155, 0x156, 0x157, 0x158, 0x159
};
void BM_collation_element_lookup_006(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 0, cps_006 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 1, cps_006 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 2, cps_006 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 3, cps_006 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 4, cps_006 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 5, cps_006 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 6, cps_006 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 7, cps_006 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 8, cps_006 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 9, cps_006 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 10, cps_006 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 11, cps_006 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 12, cps_006 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 13, cps_006 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 14, cps_006 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 15, cps_006 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 16, cps_006 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 17, cps_006 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 18, cps_006 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 19, cps_006 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 20, cps_006 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 21, cps_006 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 22, cps_006 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 23, cps_006 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 24, cps_006 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 25, cps_006 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 26, cps_006 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 27, cps_006 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 28, cps_006 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 29, cps_006 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 30, cps_006 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 31, cps_006 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 32, cps_006 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 33, cps_006 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 34, cps_006 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 35, cps_006 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 36, cps_006 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 37, cps_006 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 38, cps_006 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 39, cps_006 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 40, cps_006 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 41, cps_006 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 42, cps_006 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 43, cps_006 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 44, cps_006 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 45, cps_006 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 46, cps_006 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 47, cps_006 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 48, cps_006 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_006 + 49, cps_006 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_006);
uint32_t cps_007[] = {
0x15a, 0x15b, 0x15c, 0x15d, 0x15e, 0x15f, 0x160, 0x161, 0x162, 0x163, 0x164, 0x165, 0x166, 0x167, 0x168, 0x169, 0x16a, 0x16b, 0x16c, 0x16d, 0x16e, 0x16f, 0x170, 0x171, 0x172, 0x173, 0x174, 0x175, 0x176, 0x177, 0x178, 0x179, 0x17a, 0x17b, 0x17c, 0x17d, 0x17e, 0x17f, 0x180, 0x181, 0x182, 0x183, 0x184, 0x185, 0x186, 0x187, 0x188, 0x189, 0x18a, 0x18b
};
void BM_collation_element_lookup_007(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 0, cps_007 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 1, cps_007 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 2, cps_007 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 3, cps_007 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 4, cps_007 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 5, cps_007 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 6, cps_007 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 7, cps_007 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 8, cps_007 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 9, cps_007 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 10, cps_007 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 11, cps_007 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 12, cps_007 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 13, cps_007 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 14, cps_007 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 15, cps_007 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 16, cps_007 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 17, cps_007 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 18, cps_007 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 19, cps_007 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 20, cps_007 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 21, cps_007 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 22, cps_007 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 23, cps_007 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 24, cps_007 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 25, cps_007 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 26, cps_007 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 27, cps_007 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 28, cps_007 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 29, cps_007 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 30, cps_007 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 31, cps_007 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 32, cps_007 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 33, cps_007 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 34, cps_007 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 35, cps_007 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 36, cps_007 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 37, cps_007 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 38, cps_007 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 39, cps_007 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 40, cps_007 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 41, cps_007 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 42, cps_007 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 43, cps_007 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 44, cps_007 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 45, cps_007 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 46, cps_007 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 47, cps_007 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 48, cps_007 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_007 + 49, cps_007 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_007);
uint32_t cps_008[] = {
0x18c, 0x18d, 0x18e, 0x18f, 0x190, 0x191, 0x192, 0x193, 0x194, 0x195, 0x196, 0x197, 0x198, 0x199, 0x19a, 0x19b, 0x19c, 0x19d, 0x19e, 0x19f, 0x1a0, 0x1a1, 0x1a2, 0x1a3, 0x1a4, 0x1a5, 0x1a6, 0x1a7, 0x1a8, 0x1a9, 0x1aa, 0x1ab, 0x1ac, 0x1ad, 0x1ae, 0x1af, 0x1b0, 0x1b1, 0x1b2, 0x1b3, 0x1b4, 0x1b5, 0x1b6, 0x1b7, 0x1b8, 0x1b9, 0x1ba, 0x1bb, 0x1bc, 0x1bd
};
void BM_collation_element_lookup_008(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 0, cps_008 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 1, cps_008 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 2, cps_008 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 3, cps_008 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 4, cps_008 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 5, cps_008 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 6, cps_008 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 7, cps_008 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 8, cps_008 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 9, cps_008 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 10, cps_008 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 11, cps_008 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 12, cps_008 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 13, cps_008 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 14, cps_008 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 15, cps_008 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 16, cps_008 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 17, cps_008 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 18, cps_008 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 19, cps_008 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 20, cps_008 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 21, cps_008 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 22, cps_008 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 23, cps_008 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 24, cps_008 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 25, cps_008 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 26, cps_008 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 27, cps_008 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 28, cps_008 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 29, cps_008 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 30, cps_008 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 31, cps_008 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 32, cps_008 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 33, cps_008 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 34, cps_008 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 35, cps_008 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 36, cps_008 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 37, cps_008 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 38, cps_008 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 39, cps_008 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 40, cps_008 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 41, cps_008 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 42, cps_008 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 43, cps_008 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 44, cps_008 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 45, cps_008 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 46, cps_008 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 47, cps_008 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 48, cps_008 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_008 + 49, cps_008 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_008);
uint32_t cps_009[] = {
0x1be, 0x1bf, 0x1c0, 0x1c1, 0x1c2, 0x1c3, 0x1c4, 0x1c5, 0x1c6, 0x1c7, 0x1c8, 0x1c9, 0x1ca, 0x1cb, 0x1cc, 0x1cd, 0x1ce, 0x1cf, 0x1d0, 0x1d1, 0x1d2, 0x1d3, 0x1d4, 0x1d5, 0x1d6, 0x1d7, 0x1d8, 0x1d9, 0x1da, 0x1db, 0x1dc, 0x1dd, 0x1de, 0x1df, 0x1e0, 0x1e1, 0x1e2, 0x1e3, 0x1e4, 0x1e5, 0x1e6, 0x1e7, 0x1e8, 0x1e9, 0x1ea, 0x1eb, 0x1ec, 0x1ed, 0x1ee, 0x1ef
};
void BM_collation_element_lookup_009(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 0, cps_009 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 1, cps_009 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 2, cps_009 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 3, cps_009 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 4, cps_009 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 5, cps_009 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 6, cps_009 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 7, cps_009 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 8, cps_009 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 9, cps_009 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 10, cps_009 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 11, cps_009 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 12, cps_009 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 13, cps_009 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 14, cps_009 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 15, cps_009 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 16, cps_009 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 17, cps_009 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 18, cps_009 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 19, cps_009 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 20, cps_009 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 21, cps_009 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 22, cps_009 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 23, cps_009 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 24, cps_009 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 25, cps_009 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 26, cps_009 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 27, cps_009 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 28, cps_009 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 29, cps_009 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 30, cps_009 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 31, cps_009 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 32, cps_009 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 33, cps_009 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 34, cps_009 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 35, cps_009 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 36, cps_009 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 37, cps_009 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 38, cps_009 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 39, cps_009 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 40, cps_009 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 41, cps_009 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 42, cps_009 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 43, cps_009 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 44, cps_009 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 45, cps_009 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 46, cps_009 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 47, cps_009 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 48, cps_009 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_009 + 49, cps_009 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_009);
uint32_t cps_010[] = {
0x1f0, 0x1f1, 0x1f2, 0x1f3, 0x1f4, 0x1f5, 0x1f6, 0x1f7, 0x1f8, 0x1f9, 0x1fa, 0x1fb, 0x1fc, 0x1fd, 0x1fe, 0x1ff, 0x200, 0x201, 0x202, 0x203, 0x204, 0x205, 0x206, 0x207, 0x208, 0x209, 0x20a, 0x20b, 0x20c, 0x20d, 0x20e, 0x20f, 0x210, 0x211, 0x212, 0x213, 0x214, 0x215, 0x216, 0x217, 0x218, 0x219, 0x21a, 0x21b, 0x21c, 0x21d, 0x21e, 0x21f, 0x220, 0x221
};
void BM_collation_element_lookup_010(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 0, cps_010 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 1, cps_010 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 2, cps_010 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 3, cps_010 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 4, cps_010 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 5, cps_010 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 6, cps_010 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 7, cps_010 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 8, cps_010 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 9, cps_010 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 10, cps_010 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 11, cps_010 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 12, cps_010 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 13, cps_010 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 14, cps_010 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 15, cps_010 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 16, cps_010 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 17, cps_010 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 18, cps_010 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 19, cps_010 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 20, cps_010 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 21, cps_010 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 22, cps_010 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 23, cps_010 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 24, cps_010 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 25, cps_010 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 26, cps_010 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 27, cps_010 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 28, cps_010 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 29, cps_010 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 30, cps_010 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 31, cps_010 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 32, cps_010 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 33, cps_010 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 34, cps_010 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 35, cps_010 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 36, cps_010 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 37, cps_010 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 38, cps_010 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 39, cps_010 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 40, cps_010 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 41, cps_010 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 42, cps_010 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 43, cps_010 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 44, cps_010 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 45, cps_010 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 46, cps_010 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 47, cps_010 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 48, cps_010 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_010 + 49, cps_010 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_010);
uint32_t cps_011[] = {
0x222, 0x223, 0x224, 0x225, 0x226, 0x227, 0x228, 0x229, 0x22a, 0x22b, 0x22c, 0x22d, 0x22e, 0x22f, 0x230, 0x231, 0x232, 0x233, 0x234, 0x235, 0x236, 0x237, 0x238, 0x239, 0x23a, 0x23b, 0x23c, 0x23d, 0x23e, 0x23f, 0x240, 0x241, 0x242, 0x243, 0x244, 0x245, 0x246, 0x247, 0x248, 0x249, 0x24a, 0x24b, 0x24c, 0x24d, 0x24e, 0x24f, 0x250, 0x251, 0x252, 0x253
};
void BM_collation_element_lookup_011(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 0, cps_011 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 1, cps_011 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 2, cps_011 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 3, cps_011 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 4, cps_011 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 5, cps_011 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 6, cps_011 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 7, cps_011 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 8, cps_011 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 9, cps_011 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 10, cps_011 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 11, cps_011 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 12, cps_011 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 13, cps_011 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 14, cps_011 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 15, cps_011 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 16, cps_011 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 17, cps_011 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 18, cps_011 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 19, cps_011 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 20, cps_011 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 21, cps_011 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 22, cps_011 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 23, cps_011 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 24, cps_011 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 25, cps_011 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 26, cps_011 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 27, cps_011 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 28, cps_011 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 29, cps_011 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 30, cps_011 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 31, cps_011 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 32, cps_011 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 33, cps_011 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 34, cps_011 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 35, cps_011 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 36, cps_011 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 37, cps_011 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 38, cps_011 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 39, cps_011 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 40, cps_011 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 41, cps_011 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 42, cps_011 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 43, cps_011 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 44, cps_011 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 45, cps_011 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 46, cps_011 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 47, cps_011 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 48, cps_011 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_011 + 49, cps_011 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_011);
uint32_t cps_012[] = {
0x254, 0x255, 0x256, 0x257, 0x258, 0x259, 0x25a, 0x25b, 0x25c, 0x25d, 0x25e, 0x25f, 0x260, 0x261, 0x262, 0x263, 0x264, 0x265, 0x266, 0x267, 0x268, 0x269, 0x26a, 0x26b, 0x26c, 0x26d, 0x26e, 0x26f, 0x270, 0x271, 0x272, 0x273, 0x274, 0x275, 0x276, 0x277, 0x278, 0x279, 0x27a, 0x27b, 0x27c, 0x27d, 0x27e, 0x27f, 0x280, 0x281, 0x282, 0x283, 0x284, 0x285
};
void BM_collation_element_lookup_012(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 0, cps_012 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 1, cps_012 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 2, cps_012 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 3, cps_012 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 4, cps_012 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 5, cps_012 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 6, cps_012 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 7, cps_012 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 8, cps_012 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 9, cps_012 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 10, cps_012 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 11, cps_012 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 12, cps_012 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 13, cps_012 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 14, cps_012 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 15, cps_012 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 16, cps_012 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 17, cps_012 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 18, cps_012 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 19, cps_012 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 20, cps_012 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 21, cps_012 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 22, cps_012 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 23, cps_012 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 24, cps_012 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 25, cps_012 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 26, cps_012 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 27, cps_012 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 28, cps_012 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 29, cps_012 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 30, cps_012 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 31, cps_012 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 32, cps_012 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 33, cps_012 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 34, cps_012 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 35, cps_012 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 36, cps_012 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 37, cps_012 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 38, cps_012 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 39, cps_012 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 40, cps_012 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 41, cps_012 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 42, cps_012 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 43, cps_012 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 44, cps_012 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 45, cps_012 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 46, cps_012 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 47, cps_012 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 48, cps_012 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_012 + 49, cps_012 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_012);
uint32_t cps_013[] = {
0x286, 0x287, 0x288, 0x289, 0x28a, 0x28b, 0x28c, 0x28d, 0x28e, 0x28f, 0x290, 0x291, 0x292, 0x293, 0x294, 0x295, 0x296, 0x297, 0x298, 0x299, 0x29a, 0x29b, 0x29c, 0x29d, 0x29e, 0x29f, 0x2a0, 0x2a1, 0x2a2, 0x2a3, 0x2a4, 0x2a5, 0x2a6, 0x2a7, 0x2a8, 0x2a9, 0x2aa, 0x2ab, 0x2ac, 0x2ad, 0x2ae, 0x2af, 0x2b0, 0x2b1, 0x2b2, 0x2b3, 0x2b4, 0x2b5, 0x2b6, 0x2b7
};
void BM_collation_element_lookup_013(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 0, cps_013 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 1, cps_013 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 2, cps_013 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 3, cps_013 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 4, cps_013 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 5, cps_013 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 6, cps_013 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 7, cps_013 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 8, cps_013 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 9, cps_013 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 10, cps_013 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 11, cps_013 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 12, cps_013 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 13, cps_013 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 14, cps_013 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 15, cps_013 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 16, cps_013 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 17, cps_013 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 18, cps_013 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 19, cps_013 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 20, cps_013 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 21, cps_013 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 22, cps_013 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 23, cps_013 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 24, cps_013 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 25, cps_013 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 26, cps_013 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 27, cps_013 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 28, cps_013 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 29, cps_013 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 30, cps_013 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 31, cps_013 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 32, cps_013 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 33, cps_013 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 34, cps_013 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 35, cps_013 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 36, cps_013 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 37, cps_013 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 38, cps_013 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 39, cps_013 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 40, cps_013 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 41, cps_013 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 42, cps_013 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 43, cps_013 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 44, cps_013 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 45, cps_013 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 46, cps_013 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 47, cps_013 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 48, cps_013 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_013 + 49, cps_013 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_013);
uint32_t cps_014[] = {
0x2b8, 0x2b9, 0x2ba, 0x2bb, 0x2bc, 0x2bd, 0x2be, 0x2bf, 0x2c0, 0x2c1, 0x2c2, 0x2c3, 0x2c4, 0x2c5, 0x2c6, 0x2c7, 0x2c8, 0x2c9, 0x2ca, 0x2cb, 0x2cc, 0x2cd, 0x2ce, 0x2cf, 0x2d0, 0x2d1, 0x2d2, 0x2d3, 0x2d4, 0x2d5, 0x2d6, 0x2d7, 0x2d8, 0x2d9, 0x2da, 0x2db, 0x2dc, 0x2dd, 0x2de, 0x2df, 0x2e0, 0x2e1, 0x2e2, 0x2e3, 0x2e4, 0x2e5, 0x2e6, 0x2e7, 0x2e8, 0x2e9
};
void BM_collation_element_lookup_014(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 0, cps_014 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 1, cps_014 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 2, cps_014 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 3, cps_014 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 4, cps_014 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 5, cps_014 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 6, cps_014 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 7, cps_014 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 8, cps_014 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 9, cps_014 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 10, cps_014 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 11, cps_014 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 12, cps_014 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 13, cps_014 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 14, cps_014 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 15, cps_014 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 16, cps_014 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 17, cps_014 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 18, cps_014 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 19, cps_014 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 20, cps_014 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 21, cps_014 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 22, cps_014 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 23, cps_014 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 24, cps_014 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 25, cps_014 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 26, cps_014 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 27, cps_014 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 28, cps_014 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 29, cps_014 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 30, cps_014 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 31, cps_014 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 32, cps_014 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 33, cps_014 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 34, cps_014 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 35, cps_014 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 36, cps_014 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 37, cps_014 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 38, cps_014 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 39, cps_014 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 40, cps_014 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 41, cps_014 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 42, cps_014 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 43, cps_014 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 44, cps_014 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 45, cps_014 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 46, cps_014 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 47, cps_014 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 48, cps_014 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_014 + 49, cps_014 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_014);
uint32_t cps_015[] = {
0x2ea, 0x2eb, 0x2ec, 0x2ed, 0x2ee, 0x2ef, 0x2f0, 0x2f1, 0x2f2, 0x2f3, 0x2f4, 0x2f5, 0x2f6, 0x2f7, 0x2f8, 0x2f9, 0x2fa, 0x2fb, 0x2fc, 0x2fd, 0x2fe, 0x2ff, 0x300, 0x301, 0x302, 0x303, 0x304, 0x305, 0x306, 0x307, 0x308, 0x309, 0x30a, 0x30b, 0x30c, 0x30d, 0x30e, 0x30f, 0x310, 0x311, 0x312, 0x313, 0x314, 0x315, 0x316, 0x317, 0x318, 0x319, 0x31a, 0x31b
};
void BM_collation_element_lookup_015(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 0, cps_015 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 1, cps_015 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 2, cps_015 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 3, cps_015 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 4, cps_015 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 5, cps_015 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 6, cps_015 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 7, cps_015 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 8, cps_015 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 9, cps_015 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 10, cps_015 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 11, cps_015 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 12, cps_015 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 13, cps_015 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 14, cps_015 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 15, cps_015 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 16, cps_015 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 17, cps_015 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 18, cps_015 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 19, cps_015 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 20, cps_015 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 21, cps_015 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 22, cps_015 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 23, cps_015 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 24, cps_015 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 25, cps_015 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 26, cps_015 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 27, cps_015 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 28, cps_015 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 29, cps_015 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 30, cps_015 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 31, cps_015 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 32, cps_015 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 33, cps_015 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 34, cps_015 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 35, cps_015 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 36, cps_015 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 37, cps_015 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 38, cps_015 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 39, cps_015 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 40, cps_015 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 41, cps_015 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 42, cps_015 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 43, cps_015 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 44, cps_015 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 45, cps_015 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 46, cps_015 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 47, cps_015 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 48, cps_015 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_015 + 49, cps_015 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_015);
uint32_t cps_016[] = {
0x31c, 0x31d, 0x31e, 0x31f, 0x320, 0x321, 0x322, 0x323, 0x324, 0x325, 0x326, 0x327, 0x328, 0x329, 0x32a, 0x32b, 0x32c, 0x32d, 0x32e, 0x32f, 0x330, 0x331, 0x332, 0x333, 0x334, 0x335, 0x336, 0x337, 0x338, 0x339, 0x33a, 0x33b, 0x33c, 0x33d, 0x33e, 0x33f, 0x340, 0x341, 0x342, 0x343, 0x344, 0x345, 0x346, 0x347, 0x348, 0x349, 0x34a, 0x34b, 0x34c, 0x34d
};
void BM_collation_element_lookup_016(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 0, cps_016 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 1, cps_016 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 2, cps_016 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 3, cps_016 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 4, cps_016 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 5, cps_016 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 6, cps_016 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 7, cps_016 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 8, cps_016 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 9, cps_016 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 10, cps_016 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 11, cps_016 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 12, cps_016 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 13, cps_016 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 14, cps_016 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 15, cps_016 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 16, cps_016 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 17, cps_016 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 18, cps_016 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 19, cps_016 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 20, cps_016 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 21, cps_016 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 22, cps_016 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 23, cps_016 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 24, cps_016 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 25, cps_016 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 26, cps_016 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 27, cps_016 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 28, cps_016 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 29, cps_016 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 30, cps_016 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 31, cps_016 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 32, cps_016 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 33, cps_016 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 34, cps_016 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 35, cps_016 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 36, cps_016 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 37, cps_016 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 38, cps_016 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 39, cps_016 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 40, cps_016 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 41, cps_016 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 42, cps_016 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 43, cps_016 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 44, cps_016 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 45, cps_016 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 46, cps_016 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 47, cps_016 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 48, cps_016 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_016 + 49, cps_016 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_016);
uint32_t cps_017[] = {
0x34e, 0x34f, 0x350, 0x351, 0x352, 0x353, 0x354, 0x355, 0x356, 0x357, 0x358, 0x359, 0x35a, 0x35b, 0x35c, 0x35d, 0x35e, 0x35f, 0x360, 0x361, 0x362, 0x363, 0x364, 0x365, 0x366, 0x367, 0x368, 0x369, 0x36a, 0x36b, 0x36c, 0x36d, 0x36e, 0x36f, 0x370, 0x371, 0x372, 0x373, 0x374, 0x375, 0x376, 0x377, 0x37a, 0x37b, 0x37c, 0x37d, 0x37e, 0x37f, 0x384, 0x385
};
void BM_collation_element_lookup_017(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 0, cps_017 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 1, cps_017 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 2, cps_017 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 3, cps_017 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 4, cps_017 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 5, cps_017 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 6, cps_017 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 7, cps_017 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 8, cps_017 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 9, cps_017 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 10, cps_017 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 11, cps_017 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 12, cps_017 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 13, cps_017 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 14, cps_017 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 15, cps_017 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 16, cps_017 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 17, cps_017 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 18, cps_017 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 19, cps_017 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 20, cps_017 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 21, cps_017 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 22, cps_017 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 23, cps_017 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 24, cps_017 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 25, cps_017 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 26, cps_017 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 27, cps_017 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 28, cps_017 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 29, cps_017 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 30, cps_017 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 31, cps_017 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 32, cps_017 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 33, cps_017 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 34, cps_017 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 35, cps_017 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 36, cps_017 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 37, cps_017 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 38, cps_017 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 39, cps_017 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 40, cps_017 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 41, cps_017 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 42, cps_017 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 43, cps_017 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 44, cps_017 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 45, cps_017 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 46, cps_017 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 47, cps_017 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 48, cps_017 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_017 + 49, cps_017 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_017);
uint32_t cps_018[] = {
0x386, 0x387, 0x388, 0x389, 0x38a, 0x38c, 0x38e, 0x38f, 0x390, 0x391, 0x392, 0x393, 0x394, 0x395, 0x396, 0x397, 0x398, 0x399, 0x39a, 0x39b, 0x39c, 0x39d, 0x39e, 0x39f, 0x3a0, 0x3a1, 0x3a3, 0x3a4, 0x3a5, 0x3a6, 0x3a7, 0x3a8, 0x3a9, 0x3aa, 0x3ab, 0x3ac, 0x3ad, 0x3ae, 0x3af, 0x3b0, 0x3b1, 0x3b2, 0x3b3, 0x3b4, 0x3b5, 0x3b6, 0x3b7, 0x3b8, 0x3b9, 0x3ba
};
void BM_collation_element_lookup_018(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 0, cps_018 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 1, cps_018 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 2, cps_018 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 3, cps_018 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 4, cps_018 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 5, cps_018 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 6, cps_018 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 7, cps_018 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 8, cps_018 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 9, cps_018 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 10, cps_018 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 11, cps_018 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 12, cps_018 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 13, cps_018 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 14, cps_018 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 15, cps_018 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 16, cps_018 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 17, cps_018 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 18, cps_018 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 19, cps_018 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 20, cps_018 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 21, cps_018 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 22, cps_018 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 23, cps_018 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 24, cps_018 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 25, cps_018 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 26, cps_018 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 27, cps_018 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 28, cps_018 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 29, cps_018 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 30, cps_018 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 31, cps_018 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 32, cps_018 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 33, cps_018 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 34, cps_018 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 35, cps_018 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 36, cps_018 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 37, cps_018 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 38, cps_018 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 39, cps_018 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 40, cps_018 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 41, cps_018 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 42, cps_018 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 43, cps_018 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 44, cps_018 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 45, cps_018 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 46, cps_018 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 47, cps_018 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 48, cps_018 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_018 + 49, cps_018 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_018);
uint32_t cps_019[] = {
0x3bb, 0x3bc, 0x3bd, 0x3be, 0x3bf, 0x3c0, 0x3c1, 0x3c2, 0x3c3, 0x3c4, 0x3c5, 0x3c6, 0x3c7, 0x3c8, 0x3c9, 0x3ca, 0x3cb, 0x3cc, 0x3cd, 0x3ce, 0x3cf, 0x3d0, 0x3d1, 0x3d2, 0x3d3, 0x3d4, 0x3d5, 0x3d6, 0x3d7, 0x3d8, 0x3d9, 0x3da, 0x3db, 0x3dc, 0x3dd, 0x3de, 0x3df, 0x3e0, 0x3e1, 0x3e2, 0x3e3, 0x3e4, 0x3e5, 0x3e6, 0x3e7, 0x3e8, 0x3e9, 0x3ea, 0x3eb, 0x3ec
};
void BM_collation_element_lookup_019(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 0, cps_019 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 1, cps_019 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 2, cps_019 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 3, cps_019 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 4, cps_019 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 5, cps_019 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 6, cps_019 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 7, cps_019 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 8, cps_019 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 9, cps_019 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 10, cps_019 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 11, cps_019 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 12, cps_019 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 13, cps_019 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 14, cps_019 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 15, cps_019 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 16, cps_019 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 17, cps_019 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 18, cps_019 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 19, cps_019 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 20, cps_019 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 21, cps_019 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 22, cps_019 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 23, cps_019 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 24, cps_019 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 25, cps_019 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 26, cps_019 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 27, cps_019 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 28, cps_019 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 29, cps_019 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 30, cps_019 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 31, cps_019 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 32, cps_019 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 33, cps_019 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 34, cps_019 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 35, cps_019 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 36, cps_019 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 37, cps_019 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 38, cps_019 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 39, cps_019 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 40, cps_019 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 41, cps_019 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 42, cps_019 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 43, cps_019 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 44, cps_019 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 45, cps_019 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 46, cps_019 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 47, cps_019 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 48, cps_019 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_019 + 49, cps_019 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_019);
uint32_t cps_020[] = {
0x3ed, 0x3ee, 0x3ef, 0x3f0, 0x3f1, 0x3f2, 0x3f3, 0x3f4, 0x3f5, 0x3f6, 0x3f7, 0x3f8, 0x3f9, 0x3fa, 0x3fb, 0x3fc, 0x3fd, 0x3fe, 0x3ff, 0x400, 0x401, 0x402, 0x403, 0x404, 0x405, 0x406, 0x407, 0x408, 0x409, 0x40a, 0x40b, 0x40c, 0x40d, 0x40e, 0x40f, 0x410, 0x411, 0x412, 0x413, 0x414, 0x415, 0x416, 0x417, 0x418, 0x418, 0x306, 0x419, 0x41a, 0x41b, 0x41c, 0x41d
};
void BM_collation_element_lookup_020(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 0, cps_020 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 1, cps_020 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 2, cps_020 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 3, cps_020 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 4, cps_020 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 5, cps_020 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 6, cps_020 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 7, cps_020 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 8, cps_020 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 9, cps_020 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 10, cps_020 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 11, cps_020 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 12, cps_020 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 13, cps_020 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 14, cps_020 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 15, cps_020 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 16, cps_020 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 17, cps_020 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 18, cps_020 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 19, cps_020 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 20, cps_020 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 21, cps_020 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 22, cps_020 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 23, cps_020 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 24, cps_020 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 25, cps_020 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 26, cps_020 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 27, cps_020 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 28, cps_020 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 29, cps_020 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 30, cps_020 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 31, cps_020 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 32, cps_020 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 33, cps_020 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 34, cps_020 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 35, cps_020 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 36, cps_020 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 37, cps_020 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 38, cps_020 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 39, cps_020 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 40, cps_020 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 41, cps_020 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 42, cps_020 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 43, cps_020 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 44, cps_020 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 46, cps_020 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 47, cps_020 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 48, cps_020 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 49, cps_020 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_020 + 50, cps_020 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_020);
uint32_t cps_021[] = {
0x41e, 0x41f, 0x420, 0x421, 0x422, 0x423, 0x424, 0x425, 0x426, 0x427, 0x428, 0x429, 0x42a, 0x42b, 0x42c, 0x42d, 0x42e, 0x42f, 0x430, 0x431, 0x432, 0x433, 0x434, 0x435, 0x436, 0x437, 0x438, 0x438, 0x306, 0x439, 0x43a, 0x43b, 0x43c, 0x43d, 0x43e, 0x43f, 0x440, 0x441, 0x442, 0x443, 0x444, 0x445, 0x446, 0x447, 0x448, 0x449, 0x44a, 0x44b, 0x44c, 0x44d, 0x44e
};
void BM_collation_element_lookup_021(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 0, cps_021 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 1, cps_021 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 2, cps_021 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 3, cps_021 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 4, cps_021 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 5, cps_021 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 6, cps_021 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 7, cps_021 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 8, cps_021 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 9, cps_021 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 10, cps_021 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 11, cps_021 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 12, cps_021 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 13, cps_021 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 14, cps_021 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 15, cps_021 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 16, cps_021 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 17, cps_021 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 18, cps_021 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 19, cps_021 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 20, cps_021 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 21, cps_021 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 22, cps_021 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 23, cps_021 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 24, cps_021 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 25, cps_021 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 26, cps_021 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 27, cps_021 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 29, cps_021 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 30, cps_021 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 31, cps_021 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 32, cps_021 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 33, cps_021 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 34, cps_021 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 35, cps_021 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 36, cps_021 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 37, cps_021 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 38, cps_021 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 39, cps_021 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 40, cps_021 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 41, cps_021 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 42, cps_021 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 43, cps_021 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 44, cps_021 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 45, cps_021 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 46, cps_021 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 47, cps_021 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 48, cps_021 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 49, cps_021 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_021 + 50, cps_021 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_021);
uint32_t cps_022[] = {
0x44f, 0x450, 0x451, 0x452, 0x453, 0x454, 0x455, 0x456, 0x457, 0x458, 0x459, 0x45a, 0x45b, 0x45c, 0x45d, 0x45e, 0x45f, 0x460, 0x461, 0x462, 0x463, 0x464, 0x465, 0x466, 0x467, 0x468, 0x469, 0x46a, 0x46b, 0x46c, 0x46d, 0x46e, 0x46f, 0x470, 0x471, 0x472, 0x473, 0x474, 0x475, 0x476, 0x477, 0x478, 0x479, 0x47a, 0x47b, 0x47c, 0x47d, 0x47e, 0x47f, 0x480
};
void BM_collation_element_lookup_022(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 0, cps_022 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 1, cps_022 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 2, cps_022 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 3, cps_022 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 4, cps_022 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 5, cps_022 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 6, cps_022 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 7, cps_022 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 8, cps_022 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 9, cps_022 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 10, cps_022 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 11, cps_022 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 12, cps_022 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 13, cps_022 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 14, cps_022 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 15, cps_022 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 16, cps_022 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 17, cps_022 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 18, cps_022 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 19, cps_022 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 20, cps_022 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 21, cps_022 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 22, cps_022 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 23, cps_022 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 24, cps_022 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 25, cps_022 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 26, cps_022 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 27, cps_022 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 28, cps_022 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 29, cps_022 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 30, cps_022 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 31, cps_022 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 32, cps_022 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 33, cps_022 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 34, cps_022 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 35, cps_022 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 36, cps_022 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 37, cps_022 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 38, cps_022 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 39, cps_022 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 40, cps_022 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 41, cps_022 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 42, cps_022 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 43, cps_022 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 44, cps_022 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 45, cps_022 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 46, cps_022 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 47, cps_022 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 48, cps_022 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_022 + 49, cps_022 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_022);
uint32_t cps_023[] = {
0x481, 0x482, 0x483, 0x484, 0x485, 0x486, 0x487, 0x488, 0x489, 0x48a, 0x48b, 0x48c, 0x48d, 0x48e, 0x48f, 0x490, 0x491, 0x492, 0x493, 0x494, 0x495, 0x496, 0x497, 0x498, 0x499, 0x49a, 0x49b, 0x49c, 0x49d, 0x49e, 0x49f, 0x4a0, 0x4a1, 0x4a2, 0x4a3, 0x4a4, 0x4a5, 0x4a6, 0x4a7, 0x4a8, 0x4a9, 0x4aa, 0x4ab, 0x4ac, 0x4ad, 0x4ae, 0x4af, 0x4b0, 0x4b1, 0x4b2
};
void BM_collation_element_lookup_023(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 0, cps_023 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 1, cps_023 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 2, cps_023 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 3, cps_023 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 4, cps_023 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 5, cps_023 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 6, cps_023 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 7, cps_023 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 8, cps_023 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 9, cps_023 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 10, cps_023 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 11, cps_023 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 12, cps_023 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 13, cps_023 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 14, cps_023 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 15, cps_023 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 16, cps_023 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 17, cps_023 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 18, cps_023 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 19, cps_023 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 20, cps_023 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 21, cps_023 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 22, cps_023 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 23, cps_023 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 24, cps_023 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 25, cps_023 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 26, cps_023 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 27, cps_023 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 28, cps_023 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 29, cps_023 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 30, cps_023 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 31, cps_023 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 32, cps_023 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 33, cps_023 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 34, cps_023 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 35, cps_023 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 36, cps_023 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 37, cps_023 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 38, cps_023 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 39, cps_023 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 40, cps_023 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 41, cps_023 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 42, cps_023 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 43, cps_023 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 44, cps_023 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 45, cps_023 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 46, cps_023 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 47, cps_023 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 48, cps_023 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_023 + 49, cps_023 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_023);
uint32_t cps_024[] = {
0x4b3, 0x4b4, 0x4b5, 0x4b6, 0x4b7, 0x4b8, 0x4b9, 0x4ba, 0x4bb, 0x4bc, 0x4bd, 0x4be, 0x4bf, 0x4c0, 0x4c1, 0x4c2, 0x4c3, 0x4c4, 0x4c5, 0x4c6, 0x4c7, 0x4c8, 0x4c9, 0x4ca, 0x4cb, 0x4cc, 0x4cd, 0x4ce, 0x4cf, 0x4d0, 0x4d1, 0x4d2, 0x4d3, 0x4d4, 0x4d5, 0x4d6, 0x4d7, 0x4d8, 0x4d9, 0x4da, 0x4db, 0x4dc, 0x4dd, 0x4de, 0x4df, 0x4e0, 0x4e1, 0x4e2, 0x4e3, 0x4e4
};
void BM_collation_element_lookup_024(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 0, cps_024 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 1, cps_024 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 2, cps_024 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 3, cps_024 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 4, cps_024 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 5, cps_024 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 6, cps_024 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 7, cps_024 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 8, cps_024 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 9, cps_024 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 10, cps_024 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 11, cps_024 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 12, cps_024 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 13, cps_024 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 14, cps_024 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 15, cps_024 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 16, cps_024 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 17, cps_024 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 18, cps_024 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 19, cps_024 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 20, cps_024 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 21, cps_024 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 22, cps_024 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 23, cps_024 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 24, cps_024 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 25, cps_024 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 26, cps_024 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 27, cps_024 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 28, cps_024 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 29, cps_024 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 30, cps_024 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 31, cps_024 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 32, cps_024 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 33, cps_024 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 34, cps_024 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 35, cps_024 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 36, cps_024 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 37, cps_024 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 38, cps_024 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 39, cps_024 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 40, cps_024 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 41, cps_024 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 42, cps_024 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 43, cps_024 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 44, cps_024 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 45, cps_024 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 46, cps_024 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 47, cps_024 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 48, cps_024 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_024 + 49, cps_024 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_024);
uint32_t cps_025[] = {
0x4e5, 0x4e6, 0x4e7, 0x4e8, 0x4e9, 0x4ea, 0x4eb, 0x4ec, 0x4ed, 0x4ee, 0x4ef, 0x4f0, 0x4f1, 0x4f2, 0x4f3, 0x4f4, 0x4f5, 0x4f6, 0x4f7, 0x4f8, 0x4f9, 0x4fa, 0x4fb, 0x4fc, 0x4fd, 0x4fe, 0x4ff, 0x500, 0x501, 0x502, 0x503, 0x504, 0x505, 0x506, 0x507, 0x508, 0x509, 0x50a, 0x50b, 0x50c, 0x50d, 0x50e, 0x50f, 0x510, 0x511, 0x512, 0x513, 0x514, 0x515, 0x516
};
void BM_collation_element_lookup_025(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 0, cps_025 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 1, cps_025 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 2, cps_025 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 3, cps_025 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 4, cps_025 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 5, cps_025 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 6, cps_025 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 7, cps_025 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 8, cps_025 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 9, cps_025 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 10, cps_025 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 11, cps_025 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 12, cps_025 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 13, cps_025 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 14, cps_025 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 15, cps_025 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 16, cps_025 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 17, cps_025 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 18, cps_025 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 19, cps_025 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 20, cps_025 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 21, cps_025 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 22, cps_025 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 23, cps_025 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 24, cps_025 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 25, cps_025 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 26, cps_025 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 27, cps_025 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 28, cps_025 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 29, cps_025 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 30, cps_025 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 31, cps_025 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 32, cps_025 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 33, cps_025 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 34, cps_025 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 35, cps_025 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 36, cps_025 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 37, cps_025 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 38, cps_025 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 39, cps_025 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 40, cps_025 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 41, cps_025 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 42, cps_025 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 43, cps_025 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 44, cps_025 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 45, cps_025 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 46, cps_025 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 47, cps_025 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 48, cps_025 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_025 + 49, cps_025 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_025);
uint32_t cps_026[] = {
0x517, 0x518, 0x519, 0x51a, 0x51b, 0x51c, 0x51d, 0x51e, 0x51f, 0x520, 0x521, 0x522, 0x523, 0x524, 0x525, 0x526, 0x527, 0x528, 0x529, 0x52a, 0x52b, 0x52c, 0x52d, 0x52e, 0x52f, 0x531, 0x532, 0x533, 0x534, 0x535, 0x536, 0x537, 0x538, 0x539, 0x53a, 0x53b, 0x53c, 0x53d, 0x53e, 0x53f, 0x540, 0x541, 0x542, 0x543, 0x544, 0x545, 0x546, 0x547, 0x548, 0x549
};
void BM_collation_element_lookup_026(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 0, cps_026 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 1, cps_026 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 2, cps_026 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 3, cps_026 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 4, cps_026 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 5, cps_026 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 6, cps_026 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 7, cps_026 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 8, cps_026 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 9, cps_026 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 10, cps_026 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 11, cps_026 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 12, cps_026 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 13, cps_026 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 14, cps_026 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 15, cps_026 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 16, cps_026 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 17, cps_026 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 18, cps_026 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 19, cps_026 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 20, cps_026 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 21, cps_026 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 22, cps_026 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 23, cps_026 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 24, cps_026 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 25, cps_026 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 26, cps_026 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 27, cps_026 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 28, cps_026 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 29, cps_026 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 30, cps_026 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 31, cps_026 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 32, cps_026 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 33, cps_026 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 34, cps_026 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 35, cps_026 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 36, cps_026 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 37, cps_026 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 38, cps_026 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 39, cps_026 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 40, cps_026 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 41, cps_026 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 42, cps_026 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 43, cps_026 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 44, cps_026 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 45, cps_026 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 46, cps_026 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 47, cps_026 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 48, cps_026 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_026 + 49, cps_026 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_026);
uint32_t cps_027[] = {
0x54a, 0x54b, 0x54c, 0x54d, 0x54e, 0x54f, 0x550, 0x551, 0x552, 0x553, 0x554, 0x555, 0x556, 0x559, 0x55a, 0x55b, 0x55c, 0x55d, 0x55e, 0x55f, 0x561, 0x562, 0x563, 0x564, 0x565, 0x566, 0x567, 0x568, 0x569, 0x56a, 0x56b, 0x56c, 0x56d, 0x56e, 0x56f, 0x570, 0x571, 0x572, 0x573, 0x574, 0x575, 0x576, 0x577, 0x578, 0x579, 0x57a, 0x57b, 0x57c, 0x57d, 0x57e
};
void BM_collation_element_lookup_027(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 0, cps_027 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 1, cps_027 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 2, cps_027 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 3, cps_027 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 4, cps_027 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 5, cps_027 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 6, cps_027 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 7, cps_027 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 8, cps_027 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 9, cps_027 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 10, cps_027 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 11, cps_027 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 12, cps_027 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 13, cps_027 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 14, cps_027 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 15, cps_027 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 16, cps_027 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 17, cps_027 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 18, cps_027 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 19, cps_027 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 20, cps_027 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 21, cps_027 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 22, cps_027 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 23, cps_027 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 24, cps_027 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 25, cps_027 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 26, cps_027 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 27, cps_027 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 28, cps_027 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 29, cps_027 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 30, cps_027 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 31, cps_027 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 32, cps_027 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 33, cps_027 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 34, cps_027 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 35, cps_027 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 36, cps_027 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 37, cps_027 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 38, cps_027 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 39, cps_027 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 40, cps_027 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 41, cps_027 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 42, cps_027 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 43, cps_027 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 44, cps_027 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 45, cps_027 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 46, cps_027 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 47, cps_027 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 48, cps_027 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_027 + 49, cps_027 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_027);
uint32_t cps_028[] = {
0x57f, 0x580, 0x581, 0x582, 0x583, 0x584, 0x585, 0x586, 0x587, 0x589, 0x58a, 0x58d, 0x58e, 0x58f, 0x591, 0x592, 0x593, 0x594, 0x595, 0x596, 0x597, 0x598, 0x599, 0x59a, 0x59b, 0x59c, 0x59d, 0x59e, 0x59f, 0x5a0, 0x5a1, 0x5a2, 0x5a3, 0x5a4, 0x5a5, 0x5a6, 0x5a7, 0x5a8, 0x5a9, 0x5aa, 0x5ab, 0x5ac, 0x5ad, 0x5ae, 0x5af, 0x5b0, 0x5b1, 0x5b2, 0x5b3, 0x5b4
};
void BM_collation_element_lookup_028(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 0, cps_028 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 1, cps_028 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 2, cps_028 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 3, cps_028 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 4, cps_028 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 5, cps_028 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 6, cps_028 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 7, cps_028 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 8, cps_028 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 9, cps_028 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 10, cps_028 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 11, cps_028 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 12, cps_028 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 13, cps_028 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 14, cps_028 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 15, cps_028 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 16, cps_028 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 17, cps_028 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 18, cps_028 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 19, cps_028 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 20, cps_028 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 21, cps_028 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 22, cps_028 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 23, cps_028 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 24, cps_028 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 25, cps_028 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 26, cps_028 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 27, cps_028 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 28, cps_028 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 29, cps_028 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 30, cps_028 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 31, cps_028 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 32, cps_028 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 33, cps_028 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 34, cps_028 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 35, cps_028 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 36, cps_028 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 37, cps_028 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 38, cps_028 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 39, cps_028 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 40, cps_028 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 41, cps_028 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 42, cps_028 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 43, cps_028 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 44, cps_028 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 45, cps_028 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 46, cps_028 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 47, cps_028 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 48, cps_028 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_028 + 49, cps_028 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_028);
uint32_t cps_029[] = {
0x5b5, 0x5b6, 0x5b7, 0x5b8, 0x5b9, 0x5ba, 0x5bb, 0x5bc, 0x5bd, 0x5be, 0x5bf, 0x5c0, 0x5c1, 0x5c2, 0x5c3, 0x5c4, 0x5c5, 0x5c6, 0x5c7, 0x5d0, 0x5d1, 0x5d2, 0x5d3, 0x5d4, 0x5d5, 0x5d6, 0x5d7, 0x5d8, 0x5d9, 0x5da, 0x5db, 0x5dc, 0x5dd, 0x5de, 0x5df, 0x5e0, 0x5e1, 0x5e2, 0x5e3, 0x5e4, 0x5e5, 0x5e6, 0x5e7, 0x5e8, 0x5e9, 0x5ea, 0x5f0, 0x5f1, 0x5f2, 0x5f3
};
void BM_collation_element_lookup_029(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 0, cps_029 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 1, cps_029 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 2, cps_029 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 3, cps_029 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 4, cps_029 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 5, cps_029 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 6, cps_029 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 7, cps_029 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 8, cps_029 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 9, cps_029 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 10, cps_029 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 11, cps_029 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 12, cps_029 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 13, cps_029 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 14, cps_029 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 15, cps_029 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 16, cps_029 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 17, cps_029 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 18, cps_029 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 19, cps_029 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 20, cps_029 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 21, cps_029 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 22, cps_029 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 23, cps_029 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 24, cps_029 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 25, cps_029 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 26, cps_029 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 27, cps_029 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 28, cps_029 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 29, cps_029 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 30, cps_029 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 31, cps_029 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 32, cps_029 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 33, cps_029 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 34, cps_029 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 35, cps_029 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 36, cps_029 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 37, cps_029 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 38, cps_029 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 39, cps_029 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 40, cps_029 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 41, cps_029 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 42, cps_029 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 43, cps_029 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 44, cps_029 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 45, cps_029 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 46, cps_029 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 47, cps_029 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 48, cps_029 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_029 + 49, cps_029 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_029);
uint32_t cps_030[] = {
0x5f4, 0x600, 0x601, 0x602, 0x603, 0x604, 0x605, 0x606, 0x607, 0x608, 0x609, 0x60a, 0x60b, 0x60c, 0x60d, 0x60e, 0x60f, 0x610, 0x611, 0x612, 0x613, 0x614, 0x615, 0x616, 0x617, 0x618, 0x619, 0x61a, 0x61b, 0x61c, 0x61e, 0x61f, 0x620, 0x621, 0x622, 0x623, 0x624, 0x625, 0x626, 0x627, 0x627, 0x653, 0x627, 0x654, 0x627, 0x655, 0x628, 0x629, 0x62a, 0x62b, 0x62c, 0x62d, 0x62e
};
void BM_collation_element_lookup_030(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 0, cps_030 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 1, cps_030 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 2, cps_030 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 3, cps_030 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 4, cps_030 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 5, cps_030 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 6, cps_030 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 7, cps_030 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 8, cps_030 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 9, cps_030 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 10, cps_030 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 11, cps_030 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 12, cps_030 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 13, cps_030 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 14, cps_030 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 15, cps_030 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 16, cps_030 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 17, cps_030 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 18, cps_030 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 19, cps_030 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 20, cps_030 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 21, cps_030 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 22, cps_030 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 23, cps_030 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 24, cps_030 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 25, cps_030 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 26, cps_030 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 27, cps_030 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 28, cps_030 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 29, cps_030 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 30, cps_030 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 31, cps_030 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 32, cps_030 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 33, cps_030 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 34, cps_030 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 35, cps_030 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 36, cps_030 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 37, cps_030 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 38, cps_030 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 39, cps_030 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 40, cps_030 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 42, cps_030 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 44, cps_030 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 46, cps_030 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 47, cps_030 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 48, cps_030 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 49, cps_030 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 50, cps_030 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 51, cps_030 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_030 + 52, cps_030 + 53));
}
}
BENCHMARK(BM_collation_element_lookup_030);
uint32_t cps_031[] = {
0x62f, 0x630, 0x631, 0x632, 0x633, 0x634, 0x635, 0x636, 0x637, 0x638, 0x639, 0x63a, 0x63b, 0x63c, 0x63d, 0x63e, 0x63f, 0x640, 0x641, 0x642, 0x643, 0x644, 0x645, 0x646, 0x647, 0x648, 0x648, 0x654, 0x649, 0x64a, 0x64a, 0x654, 0x64b, 0x64c, 0x64d, 0x64e, 0x64f, 0x650, 0x651, 0x652, 0x653, 0x654, 0x655, 0x656, 0x657, 0x658, 0x659, 0x65a, 0x65b, 0x65c, 0x65d, 0x65e
};
void BM_collation_element_lookup_031(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 0, cps_031 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 1, cps_031 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 2, cps_031 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 3, cps_031 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 4, cps_031 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 5, cps_031 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 6, cps_031 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 7, cps_031 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 8, cps_031 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 9, cps_031 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 10, cps_031 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 11, cps_031 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 12, cps_031 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 13, cps_031 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 14, cps_031 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 15, cps_031 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 16, cps_031 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 17, cps_031 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 18, cps_031 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 19, cps_031 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 20, cps_031 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 21, cps_031 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 22, cps_031 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 23, cps_031 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 24, cps_031 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 25, cps_031 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 26, cps_031 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 28, cps_031 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 29, cps_031 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 30, cps_031 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 32, cps_031 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 33, cps_031 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 34, cps_031 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 35, cps_031 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 36, cps_031 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 37, cps_031 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 38, cps_031 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 39, cps_031 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 40, cps_031 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 41, cps_031 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 42, cps_031 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 43, cps_031 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 44, cps_031 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 45, cps_031 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 46, cps_031 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 47, cps_031 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 48, cps_031 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 49, cps_031 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 50, cps_031 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_031 + 51, cps_031 + 52));
}
}
BENCHMARK(BM_collation_element_lookup_031);
uint32_t cps_032[] = {
0x65f, 0x660, 0x661, 0x662, 0x663, 0x664, 0x665, 0x666, 0x667, 0x668, 0x669, 0x66a, 0x66b, 0x66c, 0x66d, 0x66e, 0x66f, 0x670, 0x671, 0x672, 0x673, 0x674, 0x675, 0x676, 0x677, 0x678, 0x679, 0x67a, 0x67b, 0x67c, 0x67d, 0x67e, 0x67f, 0x680, 0x681, 0x682, 0x683, 0x684, 0x685, 0x686, 0x687, 0x688, 0x689, 0x68a, 0x68b, 0x68c, 0x68d, 0x68e, 0x68f, 0x690
};
void BM_collation_element_lookup_032(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 0, cps_032 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 1, cps_032 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 2, cps_032 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 3, cps_032 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 4, cps_032 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 5, cps_032 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 6, cps_032 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 7, cps_032 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 8, cps_032 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 9, cps_032 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 10, cps_032 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 11, cps_032 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 12, cps_032 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 13, cps_032 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 14, cps_032 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 15, cps_032 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 16, cps_032 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 17, cps_032 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 18, cps_032 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 19, cps_032 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 20, cps_032 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 21, cps_032 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 22, cps_032 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 23, cps_032 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 24, cps_032 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 25, cps_032 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 26, cps_032 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 27, cps_032 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 28, cps_032 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 29, cps_032 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 30, cps_032 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 31, cps_032 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 32, cps_032 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 33, cps_032 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 34, cps_032 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 35, cps_032 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 36, cps_032 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 37, cps_032 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 38, cps_032 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 39, cps_032 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 40, cps_032 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 41, cps_032 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 42, cps_032 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 43, cps_032 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 44, cps_032 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 45, cps_032 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 46, cps_032 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 47, cps_032 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 48, cps_032 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_032 + 49, cps_032 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_032);
uint32_t cps_033[] = {
0x691, 0x692, 0x693, 0x694, 0x695, 0x696, 0x697, 0x698, 0x699, 0x69a, 0x69b, 0x69c, 0x69d, 0x69e, 0x69f, 0x6a0, 0x6a1, 0x6a2, 0x6a3, 0x6a4, 0x6a5, 0x6a6, 0x6a7, 0x6a8, 0x6a9, 0x6aa, 0x6ab, 0x6ac, 0x6ad, 0x6ae, 0x6af, 0x6b0, 0x6b1, 0x6b2, 0x6b3, 0x6b4, 0x6b5, 0x6b6, 0x6b7, 0x6b8, 0x6b9, 0x6ba, 0x6bb, 0x6bc, 0x6bd, 0x6be, 0x6bf, 0x6c0, 0x6c1, 0x6c2
};
void BM_collation_element_lookup_033(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 0, cps_033 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 1, cps_033 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 2, cps_033 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 3, cps_033 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 4, cps_033 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 5, cps_033 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 6, cps_033 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 7, cps_033 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 8, cps_033 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 9, cps_033 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 10, cps_033 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 11, cps_033 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 12, cps_033 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 13, cps_033 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 14, cps_033 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 15, cps_033 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 16, cps_033 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 17, cps_033 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 18, cps_033 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 19, cps_033 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 20, cps_033 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 21, cps_033 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 22, cps_033 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 23, cps_033 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 24, cps_033 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 25, cps_033 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 26, cps_033 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 27, cps_033 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 28, cps_033 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 29, cps_033 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 30, cps_033 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 31, cps_033 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 32, cps_033 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 33, cps_033 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 34, cps_033 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 35, cps_033 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 36, cps_033 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 37, cps_033 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 38, cps_033 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 39, cps_033 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 40, cps_033 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 41, cps_033 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 42, cps_033 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 43, cps_033 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 44, cps_033 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 45, cps_033 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 46, cps_033 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 47, cps_033 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 48, cps_033 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_033 + 49, cps_033 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_033);
uint32_t cps_034[] = {
0x6c3, 0x6c4, 0x6c5, 0x6c6, 0x6c7, 0x6c8, 0x6c9, 0x6ca, 0x6cb, 0x6cc, 0x6cd, 0x6ce, 0x6cf, 0x6d0, 0x6d1, 0x6d2, 0x6d3, 0x6d4, 0x6d5, 0x6d6, 0x6d7, 0x6d8, 0x6d9, 0x6da, 0x6db, 0x6dc, 0x6dd, 0x6de, 0x6df, 0x6e0, 0x6e1, 0x6e2, 0x6e3, 0x6e4, 0x6e5, 0x6e6, 0x6e7, 0x6e8, 0x6e9, 0x6ea, 0x6eb, 0x6ec, 0x6ed, 0x6ee, 0x6ef, 0x6f0, 0x6f1, 0x6f2, 0x6f3, 0x6f4
};
void BM_collation_element_lookup_034(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 0, cps_034 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 1, cps_034 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 2, cps_034 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 3, cps_034 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 4, cps_034 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 5, cps_034 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 6, cps_034 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 7, cps_034 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 8, cps_034 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 9, cps_034 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 10, cps_034 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 11, cps_034 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 12, cps_034 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 13, cps_034 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 14, cps_034 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 15, cps_034 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 16, cps_034 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 17, cps_034 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 18, cps_034 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 19, cps_034 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 20, cps_034 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 21, cps_034 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 22, cps_034 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 23, cps_034 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 24, cps_034 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 25, cps_034 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 26, cps_034 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 27, cps_034 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 28, cps_034 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 29, cps_034 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 30, cps_034 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 31, cps_034 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 32, cps_034 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 33, cps_034 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 34, cps_034 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 35, cps_034 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 36, cps_034 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 37, cps_034 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 38, cps_034 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 39, cps_034 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 40, cps_034 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 41, cps_034 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 42, cps_034 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 43, cps_034 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 44, cps_034 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 45, cps_034 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 46, cps_034 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 47, cps_034 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 48, cps_034 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_034 + 49, cps_034 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_034);
uint32_t cps_035[] = {
0x6f5, 0x6f6, 0x6f7, 0x6f8, 0x6f9, 0x6fa, 0x6fb, 0x6fc, 0x6fd, 0x6fe, 0x6ff, 0x700, 0x701, 0x702, 0x703, 0x704, 0x705, 0x706, 0x707, 0x708, 0x709, 0x70a, 0x70b, 0x70c, 0x70d, 0x70f, 0x710, 0x711, 0x712, 0x713, 0x714, 0x715, 0x716, 0x717, 0x718, 0x719, 0x71a, 0x71b, 0x71c, 0x71d, 0x71e, 0x71f, 0x720, 0x721, 0x722, 0x723, 0x724, 0x725, 0x726, 0x727
};
void BM_collation_element_lookup_035(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 0, cps_035 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 1, cps_035 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 2, cps_035 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 3, cps_035 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 4, cps_035 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 5, cps_035 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 6, cps_035 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 7, cps_035 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 8, cps_035 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 9, cps_035 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 10, cps_035 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 11, cps_035 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 12, cps_035 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 13, cps_035 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 14, cps_035 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 15, cps_035 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 16, cps_035 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 17, cps_035 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 18, cps_035 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 19, cps_035 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 20, cps_035 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 21, cps_035 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 22, cps_035 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 23, cps_035 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 24, cps_035 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 25, cps_035 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 26, cps_035 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 27, cps_035 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 28, cps_035 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 29, cps_035 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 30, cps_035 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 31, cps_035 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 32, cps_035 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 33, cps_035 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 34, cps_035 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 35, cps_035 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 36, cps_035 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 37, cps_035 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 38, cps_035 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 39, cps_035 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 40, cps_035 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 41, cps_035 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 42, cps_035 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 43, cps_035 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 44, cps_035 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 45, cps_035 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 46, cps_035 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 47, cps_035 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 48, cps_035 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_035 + 49, cps_035 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_035);
uint32_t cps_036[] = {
0x728, 0x729, 0x72a, 0x72b, 0x72c, 0x72d, 0x72e, 0x72f, 0x730, 0x731, 0x732, 0x733, 0x734, 0x735, 0x736, 0x737, 0x738, 0x739, 0x73a, 0x73b, 0x73c, 0x73d, 0x73e, 0x73f, 0x740, 0x741, 0x742, 0x743, 0x744, 0x745, 0x746, 0x747, 0x748, 0x749, 0x74a, 0x74d, 0x74e, 0x74f, 0x750, 0x751, 0x752, 0x753, 0x754, 0x755, 0x756, 0x757, 0x758, 0x759, 0x75a, 0x75b
};
void BM_collation_element_lookup_036(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 0, cps_036 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 1, cps_036 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 2, cps_036 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 3, cps_036 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 4, cps_036 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 5, cps_036 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 6, cps_036 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 7, cps_036 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 8, cps_036 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 9, cps_036 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 10, cps_036 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 11, cps_036 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 12, cps_036 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 13, cps_036 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 14, cps_036 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 15, cps_036 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 16, cps_036 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 17, cps_036 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 18, cps_036 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 19, cps_036 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 20, cps_036 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 21, cps_036 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 22, cps_036 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 23, cps_036 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 24, cps_036 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 25, cps_036 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 26, cps_036 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 27, cps_036 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 28, cps_036 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 29, cps_036 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 30, cps_036 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 31, cps_036 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 32, cps_036 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 33, cps_036 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 34, cps_036 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 35, cps_036 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 36, cps_036 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 37, cps_036 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 38, cps_036 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 39, cps_036 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 40, cps_036 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 41, cps_036 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 42, cps_036 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 43, cps_036 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 44, cps_036 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 45, cps_036 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 46, cps_036 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 47, cps_036 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 48, cps_036 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_036 + 49, cps_036 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_036);
uint32_t cps_037[] = {
0x75c, 0x75d, 0x75e, 0x75f, 0x760, 0x761, 0x762, 0x763, 0x764, 0x765, 0x766, 0x767, 0x768, 0x769, 0x76a, 0x76b, 0x76c, 0x76d, 0x76e, 0x76f, 0x770, 0x771, 0x772, 0x773, 0x774, 0x775, 0x776, 0x777, 0x778, 0x779, 0x77a, 0x77b, 0x77c, 0x77d, 0x77e, 0x77f, 0x780, 0x781, 0x782, 0x783, 0x784, 0x785, 0x786, 0x787, 0x788, 0x789, 0x78a, 0x78b, 0x78c, 0x78d
};
void BM_collation_element_lookup_037(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 0, cps_037 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 1, cps_037 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 2, cps_037 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 3, cps_037 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 4, cps_037 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 5, cps_037 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 6, cps_037 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 7, cps_037 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 8, cps_037 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 9, cps_037 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 10, cps_037 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 11, cps_037 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 12, cps_037 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 13, cps_037 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 14, cps_037 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 15, cps_037 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 16, cps_037 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 17, cps_037 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 18, cps_037 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 19, cps_037 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 20, cps_037 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 21, cps_037 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 22, cps_037 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 23, cps_037 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 24, cps_037 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 25, cps_037 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 26, cps_037 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 27, cps_037 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 28, cps_037 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 29, cps_037 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 30, cps_037 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 31, cps_037 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 32, cps_037 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 33, cps_037 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 34, cps_037 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 35, cps_037 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 36, cps_037 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 37, cps_037 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 38, cps_037 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 39, cps_037 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 40, cps_037 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 41, cps_037 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 42, cps_037 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 43, cps_037 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 44, cps_037 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 45, cps_037 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 46, cps_037 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 47, cps_037 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 48, cps_037 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_037 + 49, cps_037 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_037);
uint32_t cps_038[] = {
0x78e, 0x78f, 0x790, 0x791, 0x792, 0x793, 0x794, 0x795, 0x796, 0x797, 0x798, 0x799, 0x79a, 0x79b, 0x79c, 0x79d, 0x79e, 0x79f, 0x7a0, 0x7a1, 0x7a2, 0x7a3, 0x7a4, 0x7a5, 0x7a6, 0x7a7, 0x7a8, 0x7a9, 0x7aa, 0x7ab, 0x7ac, 0x7ad, 0x7ae, 0x7af, 0x7b0, 0x7b1, 0x7c0, 0x7c1, 0x7c2, 0x7c3, 0x7c4, 0x7c5, 0x7c6, 0x7c7, 0x7c8, 0x7c9, 0x7ca, 0x7cb, 0x7cc, 0x7cd
};
void BM_collation_element_lookup_038(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 0, cps_038 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 1, cps_038 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 2, cps_038 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 3, cps_038 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 4, cps_038 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 5, cps_038 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 6, cps_038 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 7, cps_038 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 8, cps_038 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 9, cps_038 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 10, cps_038 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 11, cps_038 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 12, cps_038 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 13, cps_038 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 14, cps_038 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 15, cps_038 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 16, cps_038 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 17, cps_038 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 18, cps_038 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 19, cps_038 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 20, cps_038 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 21, cps_038 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 22, cps_038 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 23, cps_038 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 24, cps_038 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 25, cps_038 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 26, cps_038 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 27, cps_038 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 28, cps_038 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 29, cps_038 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 30, cps_038 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 31, cps_038 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 32, cps_038 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 33, cps_038 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 34, cps_038 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 35, cps_038 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 36, cps_038 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 37, cps_038 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 38, cps_038 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 39, cps_038 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 40, cps_038 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 41, cps_038 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 42, cps_038 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 43, cps_038 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 44, cps_038 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 45, cps_038 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 46, cps_038 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 47, cps_038 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 48, cps_038 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_038 + 49, cps_038 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_038);
uint32_t cps_039[] = {
0x7ce, 0x7cf, 0x7d0, 0x7d1, 0x7d2, 0x7d3, 0x7d4, 0x7d5, 0x7d6, 0x7d7, 0x7d8, 0x7d9, 0x7da, 0x7db, 0x7dc, 0x7dd, 0x7de, 0x7df, 0x7e0, 0x7e1, 0x7e2, 0x7e3, 0x7e4, 0x7e5, 0x7e6, 0x7e7, 0x7e8, 0x7e9, 0x7ea, 0x7eb, 0x7ec, 0x7ed, 0x7ee, 0x7ef, 0x7f0, 0x7f1, 0x7f2, 0x7f3, 0x7f4, 0x7f5, 0x7f6, 0x7f7, 0x7f8, 0x7f9, 0x7fa, 0x800, 0x801, 0x802, 0x803, 0x804
};
void BM_collation_element_lookup_039(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 0, cps_039 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 1, cps_039 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 2, cps_039 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 3, cps_039 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 4, cps_039 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 5, cps_039 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 6, cps_039 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 7, cps_039 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 8, cps_039 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 9, cps_039 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 10, cps_039 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 11, cps_039 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 12, cps_039 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 13, cps_039 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 14, cps_039 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 15, cps_039 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 16, cps_039 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 17, cps_039 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 18, cps_039 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 19, cps_039 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 20, cps_039 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 21, cps_039 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 22, cps_039 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 23, cps_039 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 24, cps_039 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 25, cps_039 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 26, cps_039 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 27, cps_039 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 28, cps_039 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 29, cps_039 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 30, cps_039 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 31, cps_039 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 32, cps_039 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 33, cps_039 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 34, cps_039 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 35, cps_039 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 36, cps_039 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 37, cps_039 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 38, cps_039 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 39, cps_039 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 40, cps_039 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 41, cps_039 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 42, cps_039 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 43, cps_039 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 44, cps_039 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 45, cps_039 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 46, cps_039 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 47, cps_039 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 48, cps_039 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_039 + 49, cps_039 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_039);
uint32_t cps_040[] = {
0x805, 0x806, 0x807, 0x808, 0x809, 0x80a, 0x80b, 0x80c, 0x80d, 0x80e, 0x80f, 0x810, 0x811, 0x812, 0x813, 0x814, 0x815, 0x816, 0x817, 0x818, 0x819, 0x81a, 0x81b, 0x81c, 0x81d, 0x81e, 0x81f, 0x820, 0x821, 0x822, 0x823, 0x824, 0x825, 0x826, 0x827, 0x828, 0x829, 0x82a, 0x82b, 0x82c, 0x82d, 0x830, 0x831, 0x832, 0x833, 0x834, 0x835, 0x836, 0x837, 0x838
};
void BM_collation_element_lookup_040(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 0, cps_040 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 1, cps_040 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 2, cps_040 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 3, cps_040 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 4, cps_040 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 5, cps_040 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 6, cps_040 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 7, cps_040 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 8, cps_040 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 9, cps_040 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 10, cps_040 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 11, cps_040 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 12, cps_040 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 13, cps_040 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 14, cps_040 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 15, cps_040 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 16, cps_040 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 17, cps_040 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 18, cps_040 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 19, cps_040 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 20, cps_040 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 21, cps_040 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 22, cps_040 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 23, cps_040 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 24, cps_040 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 25, cps_040 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 26, cps_040 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 27, cps_040 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 28, cps_040 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 29, cps_040 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 30, cps_040 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 31, cps_040 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 32, cps_040 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 33, cps_040 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 34, cps_040 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 35, cps_040 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 36, cps_040 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 37, cps_040 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 38, cps_040 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 39, cps_040 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 40, cps_040 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 41, cps_040 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 42, cps_040 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 43, cps_040 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 44, cps_040 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 45, cps_040 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 46, cps_040 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 47, cps_040 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 48, cps_040 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_040 + 49, cps_040 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_040);
uint32_t cps_041[] = {
0x839, 0x83a, 0x83b, 0x83c, 0x83d, 0x83e, 0x840, 0x841, 0x842, 0x843, 0x844, 0x845, 0x846, 0x847, 0x848, 0x849, 0x84a, 0x84b, 0x84c, 0x84d, 0x84e, 0x84f, 0x850, 0x851, 0x852, 0x853, 0x854, 0x855, 0x856, 0x857, 0x858, 0x859, 0x85a, 0x85b, 0x85e, 0x860, 0x861, 0x862, 0x863, 0x864, 0x865, 0x866, 0x867, 0x868, 0x869, 0x86a, 0x8a0, 0x8a1, 0x8a2, 0x8a3
};
void BM_collation_element_lookup_041(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 0, cps_041 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 1, cps_041 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 2, cps_041 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 3, cps_041 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 4, cps_041 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 5, cps_041 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 6, cps_041 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 7, cps_041 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 8, cps_041 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 9, cps_041 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 10, cps_041 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 11, cps_041 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 12, cps_041 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 13, cps_041 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 14, cps_041 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 15, cps_041 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 16, cps_041 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 17, cps_041 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 18, cps_041 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 19, cps_041 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 20, cps_041 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 21, cps_041 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 22, cps_041 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 23, cps_041 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 24, cps_041 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 25, cps_041 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 26, cps_041 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 27, cps_041 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 28, cps_041 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 29, cps_041 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 30, cps_041 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 31, cps_041 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 32, cps_041 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 33, cps_041 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 34, cps_041 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 35, cps_041 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 36, cps_041 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 37, cps_041 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 38, cps_041 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 39, cps_041 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 40, cps_041 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 41, cps_041 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 42, cps_041 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 43, cps_041 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 44, cps_041 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 45, cps_041 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 46, cps_041 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 47, cps_041 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 48, cps_041 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_041 + 49, cps_041 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_041);
uint32_t cps_042[] = {
0x8a4, 0x8a5, 0x8a6, 0x8a7, 0x8a8, 0x8a9, 0x8aa, 0x8ab, 0x8ac, 0x8ad, 0x8ae, 0x8af, 0x8b0, 0x8b1, 0x8b2, 0x8b3, 0x8b4, 0x8b6, 0x8b7, 0x8b8, 0x8b9, 0x8ba, 0x8bb, 0x8bc, 0x8bd, 0x8d4, 0x8d5, 0x8d6, 0x8d7, 0x8d8, 0x8d9, 0x8da, 0x8db, 0x8dc, 0x8dd, 0x8de, 0x8df, 0x8e0, 0x8e1, 0x8e2, 0x8e3, 0x8e4, 0x8e5, 0x8e6, 0x8e7, 0x8e8, 0x8e9, 0x8ea, 0x8eb, 0x8ec
};
void BM_collation_element_lookup_042(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 0, cps_042 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 1, cps_042 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 2, cps_042 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 3, cps_042 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 4, cps_042 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 5, cps_042 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 6, cps_042 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 7, cps_042 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 8, cps_042 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 9, cps_042 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 10, cps_042 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 11, cps_042 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 12, cps_042 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 13, cps_042 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 14, cps_042 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 15, cps_042 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 16, cps_042 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 17, cps_042 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 18, cps_042 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 19, cps_042 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 20, cps_042 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 21, cps_042 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 22, cps_042 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 23, cps_042 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 24, cps_042 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 25, cps_042 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 26, cps_042 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 27, cps_042 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 28, cps_042 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 29, cps_042 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 30, cps_042 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 31, cps_042 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 32, cps_042 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 33, cps_042 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 34, cps_042 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 35, cps_042 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 36, cps_042 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 37, cps_042 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 38, cps_042 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 39, cps_042 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 40, cps_042 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 41, cps_042 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 42, cps_042 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 43, cps_042 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 44, cps_042 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 45, cps_042 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 46, cps_042 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 47, cps_042 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 48, cps_042 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_042 + 49, cps_042 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_042);
uint32_t cps_043[] = {
0x8ed, 0x8ee, 0x8ef, 0x8f0, 0x8f1, 0x8f2, 0x8f3, 0x8f4, 0x8f5, 0x8f6, 0x8f7, 0x8f8, 0x8f9, 0x8fa, 0x8fb, 0x8fc, 0x8fd, 0x8fe, 0x8ff, 0x900, 0x901, 0x902, 0x903, 0x904, 0x905, 0x906, 0x907, 0x908, 0x909, 0x90a, 0x90b, 0x90c, 0x90d, 0x90e, 0x90f, 0x910, 0x911, 0x912, 0x913, 0x914, 0x915, 0x916, 0x917, 0x918, 0x919, 0x91a, 0x91b, 0x91c, 0x91d, 0x91e
};
void BM_collation_element_lookup_043(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 0, cps_043 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 1, cps_043 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 2, cps_043 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 3, cps_043 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 4, cps_043 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 5, cps_043 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 6, cps_043 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 7, cps_043 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 8, cps_043 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 9, cps_043 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 10, cps_043 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 11, cps_043 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 12, cps_043 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 13, cps_043 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 14, cps_043 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 15, cps_043 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 16, cps_043 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 17, cps_043 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 18, cps_043 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 19, cps_043 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 20, cps_043 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 21, cps_043 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 22, cps_043 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 23, cps_043 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 24, cps_043 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 25, cps_043 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 26, cps_043 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 27, cps_043 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 28, cps_043 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 29, cps_043 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 30, cps_043 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 31, cps_043 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 32, cps_043 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 33, cps_043 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 34, cps_043 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 35, cps_043 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 36, cps_043 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 37, cps_043 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 38, cps_043 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 39, cps_043 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 40, cps_043 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 41, cps_043 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 42, cps_043 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 43, cps_043 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 44, cps_043 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 45, cps_043 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 46, cps_043 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 47, cps_043 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 48, cps_043 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_043 + 49, cps_043 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_043);
uint32_t cps_044[] = {
0x91f, 0x920, 0x921, 0x922, 0x923, 0x924, 0x925, 0x926, 0x927, 0x928, 0x929, 0x92a, 0x92b, 0x92c, 0x92d, 0x92e, 0x92f, 0x930, 0x931, 0x932, 0x933, 0x934, 0x935, 0x936, 0x937, 0x938, 0x939, 0x93a, 0x93b, 0x93c, 0x93d, 0x93e, 0x93f, 0x940, 0x941, 0x942, 0x943, 0x944, 0x945, 0x946, 0x947, 0x948, 0x949, 0x94a, 0x94b, 0x94c, 0x94d, 0x94e, 0x94f, 0x950
};
void BM_collation_element_lookup_044(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 0, cps_044 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 1, cps_044 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 2, cps_044 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 3, cps_044 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 4, cps_044 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 5, cps_044 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 6, cps_044 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 7, cps_044 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 8, cps_044 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 9, cps_044 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 10, cps_044 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 11, cps_044 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 12, cps_044 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 13, cps_044 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 14, cps_044 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 15, cps_044 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 16, cps_044 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 17, cps_044 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 18, cps_044 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 19, cps_044 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 20, cps_044 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 21, cps_044 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 22, cps_044 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 23, cps_044 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 24, cps_044 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 25, cps_044 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 26, cps_044 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 27, cps_044 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 28, cps_044 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 29, cps_044 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 30, cps_044 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 31, cps_044 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 32, cps_044 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 33, cps_044 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 34, cps_044 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 35, cps_044 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 36, cps_044 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 37, cps_044 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 38, cps_044 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 39, cps_044 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 40, cps_044 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 41, cps_044 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 42, cps_044 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 43, cps_044 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 44, cps_044 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 45, cps_044 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 46, cps_044 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 47, cps_044 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 48, cps_044 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_044 + 49, cps_044 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_044);
uint32_t cps_045[] = {
0x951, 0x952, 0x953, 0x954, 0x955, 0x956, 0x957, 0x958, 0x959, 0x95a, 0x95b, 0x95c, 0x95d, 0x95e, 0x95f, 0x960, 0x961, 0x962, 0x963, 0x964, 0x965, 0x966, 0x967, 0x968, 0x969, 0x96a, 0x96b, 0x96c, 0x96d, 0x96e, 0x96f, 0x970, 0x971, 0x972, 0x973, 0x974, 0x975, 0x976, 0x977, 0x978, 0x979, 0x97a, 0x97b, 0x97c, 0x97d, 0x97e, 0x97f, 0x980, 0x981, 0x982
};
void BM_collation_element_lookup_045(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 0, cps_045 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 1, cps_045 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 2, cps_045 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 3, cps_045 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 4, cps_045 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 5, cps_045 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 6, cps_045 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 7, cps_045 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 8, cps_045 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 9, cps_045 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 10, cps_045 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 11, cps_045 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 12, cps_045 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 13, cps_045 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 14, cps_045 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 15, cps_045 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 16, cps_045 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 17, cps_045 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 18, cps_045 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 19, cps_045 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 20, cps_045 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 21, cps_045 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 22, cps_045 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 23, cps_045 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 24, cps_045 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 25, cps_045 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 26, cps_045 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 27, cps_045 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 28, cps_045 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 29, cps_045 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 30, cps_045 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 31, cps_045 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 32, cps_045 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 33, cps_045 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 34, cps_045 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 35, cps_045 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 36, cps_045 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 37, cps_045 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 38, cps_045 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 39, cps_045 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 40, cps_045 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 41, cps_045 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 42, cps_045 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 43, cps_045 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 44, cps_045 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 45, cps_045 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 46, cps_045 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 47, cps_045 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 48, cps_045 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_045 + 49, cps_045 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_045);
uint32_t cps_046[] = {
0x983, 0x985, 0x986, 0x987, 0x988, 0x989, 0x98a, 0x98b, 0x98c, 0x98f, 0x990, 0x993, 0x994, 0x995, 0x996, 0x997, 0x998, 0x999, 0x99a, 0x99b, 0x99c, 0x99d, 0x99e, 0x99f, 0x9a0, 0x9a1, 0x9a2, 0x9a3, 0x9a4, 0x9a5, 0x9a6, 0x9a7, 0x9a8, 0x9aa, 0x9ab, 0x9ac, 0x9ad, 0x9ae, 0x9af, 0x9b0, 0x9b2, 0x9b6, 0x9b7, 0x9b8, 0x9b9, 0x9bc, 0x9bd, 0x9be, 0x9bf, 0x9c0
};
void BM_collation_element_lookup_046(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 0, cps_046 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 1, cps_046 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 2, cps_046 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 3, cps_046 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 4, cps_046 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 5, cps_046 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 6, cps_046 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 7, cps_046 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 8, cps_046 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 9, cps_046 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 10, cps_046 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 11, cps_046 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 12, cps_046 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 13, cps_046 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 14, cps_046 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 15, cps_046 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 16, cps_046 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 17, cps_046 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 18, cps_046 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 19, cps_046 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 20, cps_046 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 21, cps_046 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 22, cps_046 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 23, cps_046 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 24, cps_046 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 25, cps_046 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 26, cps_046 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 27, cps_046 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 28, cps_046 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 29, cps_046 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 30, cps_046 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 31, cps_046 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 32, cps_046 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 33, cps_046 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 34, cps_046 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 35, cps_046 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 36, cps_046 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 37, cps_046 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 38, cps_046 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 39, cps_046 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 40, cps_046 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 41, cps_046 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 42, cps_046 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 43, cps_046 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 44, cps_046 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 45, cps_046 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 46, cps_046 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 47, cps_046 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 48, cps_046 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_046 + 49, cps_046 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_046);
uint32_t cps_047[] = {
0x9c1, 0x9c2, 0x9c3, 0x9c4, 0x9c7, 0x9c7, 0x9be, 0x9c7, 0x9d7, 0x9c8, 0x9cb, 0x9cc, 0x9cd, 0x9ce, 0x9d7, 0x9dc, 0x9dd, 0x9df, 0x9e0, 0x9e1, 0x9e2, 0x9e3, 0x9e6, 0x9e7, 0x9e8, 0x9e9, 0x9ea, 0x9eb, 0x9ec, 0x9ed, 0x9ee, 0x9ef, 0x9f0, 0x9f1, 0x9f2, 0x9f3, 0x9f4, 0x9f5, 0x9f6, 0x9f7, 0x9f8, 0x9f9, 0x9fa, 0x9fb, 0x9fc, 0x9fd, 0xa01, 0xa02, 0xa03, 0xa05, 0xa06, 0xa07
};
void BM_collation_element_lookup_047(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 0, cps_047 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 1, cps_047 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 2, cps_047 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 3, cps_047 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 4, cps_047 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 5, cps_047 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 7, cps_047 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 9, cps_047 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 10, cps_047 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 11, cps_047 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 12, cps_047 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 13, cps_047 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 14, cps_047 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 15, cps_047 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 16, cps_047 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 17, cps_047 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 18, cps_047 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 19, cps_047 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 20, cps_047 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 21, cps_047 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 22, cps_047 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 23, cps_047 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 24, cps_047 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 25, cps_047 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 26, cps_047 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 27, cps_047 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 28, cps_047 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 29, cps_047 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 30, cps_047 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 31, cps_047 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 32, cps_047 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 33, cps_047 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 34, cps_047 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 35, cps_047 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 36, cps_047 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 37, cps_047 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 38, cps_047 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 39, cps_047 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 40, cps_047 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 41, cps_047 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 42, cps_047 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 43, cps_047 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 44, cps_047 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 45, cps_047 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 46, cps_047 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 47, cps_047 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 48, cps_047 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 49, cps_047 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 50, cps_047 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_047 + 51, cps_047 + 52));
}
}
BENCHMARK(BM_collation_element_lookup_047);
uint32_t cps_048[] = {
0xa08, 0xa09, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa14, 0xa15, 0xa16, 0xa17, 0xa18, 0xa19, 0xa1a, 0xa1b, 0xa1c, 0xa1d, 0xa1e, 0xa1f, 0xa20, 0xa21, 0xa22, 0xa23, 0xa24, 0xa25, 0xa26, 0xa27, 0xa28, 0xa2a, 0xa2b, 0xa2c, 0xa2d, 0xa2e, 0xa2f, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa3c, 0xa3e, 0xa3f, 0xa40, 0xa41, 0xa42, 0xa47, 0xa48, 0xa4b, 0xa4c
};
void BM_collation_element_lookup_048(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 0, cps_048 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 1, cps_048 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 2, cps_048 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 3, cps_048 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 4, cps_048 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 5, cps_048 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 6, cps_048 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 7, cps_048 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 8, cps_048 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 9, cps_048 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 10, cps_048 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 11, cps_048 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 12, cps_048 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 13, cps_048 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 14, cps_048 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 15, cps_048 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 16, cps_048 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 17, cps_048 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 18, cps_048 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 19, cps_048 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 20, cps_048 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 21, cps_048 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 22, cps_048 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 23, cps_048 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 24, cps_048 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 25, cps_048 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 26, cps_048 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 27, cps_048 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 28, cps_048 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 29, cps_048 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 30, cps_048 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 31, cps_048 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 32, cps_048 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 33, cps_048 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 34, cps_048 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 35, cps_048 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 36, cps_048 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 37, cps_048 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 38, cps_048 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 39, cps_048 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 40, cps_048 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 41, cps_048 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 42, cps_048 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 43, cps_048 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 44, cps_048 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 45, cps_048 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 46, cps_048 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 47, cps_048 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 48, cps_048 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_048 + 49, cps_048 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_048);
uint32_t cps_049[] = {
0xa4d, 0xa51, 0xa59, 0xa5a, 0xa5b, 0xa5c, 0xa5e, 0xa66, 0xa67, 0xa68, 0xa69, 0xa6a, 0xa6b, 0xa6c, 0xa6d, 0xa6e, 0xa6f, 0xa70, 0xa71, 0xa72, 0xa73, 0xa74, 0xa75, 0xa81, 0xa82, 0xa83, 0xa85, 0xa86, 0xa87, 0xa88, 0xa89, 0xa8a, 0xa8b, 0xa8c, 0xa8d, 0xa8f, 0xa90, 0xa91, 0xa93, 0xa94, 0xa95, 0xa96, 0xa97, 0xa98, 0xa99, 0xa9a, 0xa9b, 0xa9c, 0xa9d, 0xa9e
};
void BM_collation_element_lookup_049(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 0, cps_049 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 1, cps_049 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 2, cps_049 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 3, cps_049 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 4, cps_049 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 5, cps_049 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 6, cps_049 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 7, cps_049 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 8, cps_049 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 9, cps_049 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 10, cps_049 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 11, cps_049 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 12, cps_049 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 13, cps_049 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 14, cps_049 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 15, cps_049 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 16, cps_049 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 17, cps_049 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 18, cps_049 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 19, cps_049 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 20, cps_049 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 21, cps_049 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 22, cps_049 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 23, cps_049 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 24, cps_049 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 25, cps_049 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 26, cps_049 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 27, cps_049 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 28, cps_049 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 29, cps_049 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 30, cps_049 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 31, cps_049 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 32, cps_049 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 33, cps_049 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 34, cps_049 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 35, cps_049 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 36, cps_049 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 37, cps_049 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 38, cps_049 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 39, cps_049 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 40, cps_049 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 41, cps_049 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 42, cps_049 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 43, cps_049 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 44, cps_049 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 45, cps_049 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 46, cps_049 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 47, cps_049 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 48, cps_049 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_049 + 49, cps_049 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_049);
uint32_t cps_050[] = {
0xa9f, 0xaa0, 0xaa1, 0xaa2, 0xaa3, 0xaa4, 0xaa5, 0xaa6, 0xaa7, 0xaa8, 0xaaa, 0xaab, 0xaac, 0xaad, 0xaae, 0xaaf, 0xab0, 0xab2, 0xab3, 0xab5, 0xab6, 0xab7, 0xab8, 0xab9, 0xabc, 0xabd, 0xabe, 0xabf, 0xac0, 0xac1, 0xac2, 0xac3, 0xac4, 0xac5, 0xac7, 0xac8, 0xac9, 0xacb, 0xacc, 0xacd, 0xad0, 0xae0, 0xae1, 0xae2, 0xae3, 0xae6, 0xae7, 0xae8, 0xae9, 0xaea
};
void BM_collation_element_lookup_050(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 0, cps_050 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 1, cps_050 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 2, cps_050 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 3, cps_050 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 4, cps_050 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 5, cps_050 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 6, cps_050 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 7, cps_050 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 8, cps_050 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 9, cps_050 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 10, cps_050 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 11, cps_050 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 12, cps_050 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 13, cps_050 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 14, cps_050 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 15, cps_050 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 16, cps_050 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 17, cps_050 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 18, cps_050 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 19, cps_050 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 20, cps_050 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 21, cps_050 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 22, cps_050 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 23, cps_050 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 24, cps_050 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 25, cps_050 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 26, cps_050 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 27, cps_050 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 28, cps_050 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 29, cps_050 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 30, cps_050 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 31, cps_050 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 32, cps_050 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 33, cps_050 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 34, cps_050 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 35, cps_050 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 36, cps_050 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 37, cps_050 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 38, cps_050 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 39, cps_050 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 40, cps_050 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 41, cps_050 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 42, cps_050 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 43, cps_050 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 44, cps_050 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 45, cps_050 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 46, cps_050 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 47, cps_050 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 48, cps_050 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_050 + 49, cps_050 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_050);
uint32_t cps_051[] = {
0xaeb, 0xaec, 0xaed, 0xaee, 0xaef, 0xaf0, 0xaf1, 0xaf9, 0xafa, 0xafb, 0xafc, 0xafd, 0xafe, 0xaff, 0xb01, 0xb02, 0xb03, 0xb05, 0xb06, 0xb07, 0xb08, 0xb09, 0xb0a, 0xb0b, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb14, 0xb15, 0xb16, 0xb17, 0xb18, 0xb19, 0xb1a, 0xb1b, 0xb1c, 0xb1d, 0xb1e, 0xb1f, 0xb20, 0xb21, 0xb22, 0xb23, 0xb24, 0xb25, 0xb26, 0xb27, 0xb28, 0xb2a
};
void BM_collation_element_lookup_051(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 0, cps_051 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 1, cps_051 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 2, cps_051 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 3, cps_051 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 4, cps_051 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 5, cps_051 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 6, cps_051 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 7, cps_051 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 8, cps_051 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 9, cps_051 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 10, cps_051 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 11, cps_051 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 12, cps_051 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 13, cps_051 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 14, cps_051 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 15, cps_051 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 16, cps_051 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 17, cps_051 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 18, cps_051 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 19, cps_051 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 20, cps_051 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 21, cps_051 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 22, cps_051 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 23, cps_051 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 24, cps_051 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 25, cps_051 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 26, cps_051 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 27, cps_051 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 28, cps_051 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 29, cps_051 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 30, cps_051 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 31, cps_051 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 32, cps_051 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 33, cps_051 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 34, cps_051 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 35, cps_051 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 36, cps_051 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 37, cps_051 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 38, cps_051 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 39, cps_051 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 40, cps_051 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 41, cps_051 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 42, cps_051 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 43, cps_051 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 44, cps_051 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 45, cps_051 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 46, cps_051 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 47, cps_051 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 48, cps_051 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_051 + 49, cps_051 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_051);
uint32_t cps_052[] = {
0xb2b, 0xb2c, 0xb2d, 0xb2e, 0xb2f, 0xb30, 0xb32, 0xb33, 0xb35, 0xb36, 0xb37, 0xb38, 0xb39, 0xb3c, 0xb3d, 0xb3e, 0xb3f, 0xb40, 0xb41, 0xb42, 0xb43, 0xb44, 0xb47, 0xb47, 0xb3e, 0xb47, 0xb56, 0xb47, 0xb57, 0xb48, 0xb4b, 0xb4c, 0xb4d, 0xb56, 0xb57, 0xb5c, 0xb5d, 0xb5f, 0xb60, 0xb61, 0xb62, 0xb63, 0xb66, 0xb67, 0xb68, 0xb69, 0xb6a, 0xb6b, 0xb6c, 0xb6d, 0xb6e, 0xb6f, 0xb70
};
void BM_collation_element_lookup_052(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 0, cps_052 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 1, cps_052 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 2, cps_052 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 3, cps_052 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 4, cps_052 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 5, cps_052 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 6, cps_052 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 7, cps_052 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 8, cps_052 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 9, cps_052 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 10, cps_052 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 11, cps_052 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 12, cps_052 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 13, cps_052 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 14, cps_052 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 15, cps_052 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 16, cps_052 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 17, cps_052 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 18, cps_052 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 19, cps_052 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 20, cps_052 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 21, cps_052 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 22, cps_052 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 23, cps_052 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 25, cps_052 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 27, cps_052 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 29, cps_052 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 30, cps_052 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 31, cps_052 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 32, cps_052 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 33, cps_052 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 34, cps_052 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 35, cps_052 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 36, cps_052 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 37, cps_052 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 38, cps_052 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 39, cps_052 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 40, cps_052 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 41, cps_052 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 42, cps_052 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 43, cps_052 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 44, cps_052 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 45, cps_052 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 46, cps_052 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 47, cps_052 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 48, cps_052 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 49, cps_052 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 50, cps_052 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 51, cps_052 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_052 + 52, cps_052 + 53));
}
}
BENCHMARK(BM_collation_element_lookup_052);
uint32_t cps_053[] = {
0xb71, 0xb72, 0xb73, 0xb74, 0xb75, 0xb76, 0xb77, 0xb82, 0xb83, 0xb85, 0xb86, 0xb87, 0xb88, 0xb89, 0xb8a, 0xb8e, 0xb8f, 0xb90, 0xb92, 0xb92, 0xbd7, 0xb93, 0xb94, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xba9, 0xbaa, 0xbae, 0xbaf, 0xbb0, 0xbb1, 0xbb2, 0xbb3, 0xbb4, 0xbb5, 0xbb6, 0xbb7, 0xbb8, 0xbb9, 0xbbe, 0xbbf, 0xbc0, 0xbc1, 0xbc2
};
void BM_collation_element_lookup_053(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 0, cps_053 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 1, cps_053 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 2, cps_053 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 3, cps_053 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 4, cps_053 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 5, cps_053 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 6, cps_053 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 7, cps_053 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 8, cps_053 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 9, cps_053 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 10, cps_053 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 11, cps_053 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 12, cps_053 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 13, cps_053 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 14, cps_053 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 15, cps_053 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 16, cps_053 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 17, cps_053 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 18, cps_053 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 19, cps_053 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 21, cps_053 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 22, cps_053 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 23, cps_053 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 24, cps_053 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 25, cps_053 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 26, cps_053 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 27, cps_053 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 28, cps_053 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 29, cps_053 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 30, cps_053 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 31, cps_053 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 32, cps_053 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 33, cps_053 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 34, cps_053 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 35, cps_053 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 36, cps_053 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 37, cps_053 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 38, cps_053 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 39, cps_053 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 40, cps_053 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 41, cps_053 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 42, cps_053 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 43, cps_053 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 44, cps_053 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 45, cps_053 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 46, cps_053 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 47, cps_053 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 48, cps_053 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 49, cps_053 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_053 + 50, cps_053 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_053);
uint32_t cps_054[] = {
0xbc6, 0xbc6, 0xbbe, 0xbc6, 0xbd7, 0xbc7, 0xbc7, 0xbbe, 0xbc8, 0xbca, 0xbcb, 0xbcc, 0xbcd, 0xbd0, 0xbd7, 0xbe6, 0xbe7, 0xbe8, 0xbe9, 0xbea, 0xbeb, 0xbec, 0xbed, 0xbee, 0xbef, 0xbf0, 0xbf1, 0xbf2, 0xbf3, 0xbf4, 0xbf5, 0xbf6, 0xbf7, 0xbf8, 0xbf9, 0xbfa, 0xc00, 0xc01, 0xc02, 0xc03, 0xc05, 0xc06, 0xc07, 0xc08, 0xc09, 0xc0a, 0xc0b, 0xc0c, 0xc0e, 0xc0f, 0xc10, 0xc12, 0xc13
};
void BM_collation_element_lookup_054(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 0, cps_054 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 1, cps_054 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 3, cps_054 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 5, cps_054 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 6, cps_054 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 8, cps_054 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 9, cps_054 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 10, cps_054 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 11, cps_054 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 12, cps_054 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 13, cps_054 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 14, cps_054 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 15, cps_054 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 16, cps_054 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 17, cps_054 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 18, cps_054 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 19, cps_054 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 20, cps_054 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 21, cps_054 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 22, cps_054 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 23, cps_054 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 24, cps_054 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 25, cps_054 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 26, cps_054 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 27, cps_054 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 28, cps_054 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 29, cps_054 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 30, cps_054 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 31, cps_054 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 32, cps_054 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 33, cps_054 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 34, cps_054 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 35, cps_054 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 36, cps_054 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 37, cps_054 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 38, cps_054 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 39, cps_054 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 40, cps_054 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 41, cps_054 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 42, cps_054 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 43, cps_054 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 44, cps_054 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 45, cps_054 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 46, cps_054 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 47, cps_054 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 48, cps_054 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 49, cps_054 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 50, cps_054 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 51, cps_054 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_054 + 52, cps_054 + 53));
}
}
BENCHMARK(BM_collation_element_lookup_054);
uint32_t cps_055[] = {
0xc14, 0xc15, 0xc16, 0xc17, 0xc18, 0xc19, 0xc1a, 0xc1b, 0xc1c, 0xc1d, 0xc1e, 0xc1f, 0xc20, 0xc21, 0xc22, 0xc23, 0xc24, 0xc25, 0xc26, 0xc27, 0xc28, 0xc2a, 0xc2b, 0xc2c, 0xc2d, 0xc2e, 0xc2f, 0xc30, 0xc31, 0xc32, 0xc33, 0xc34, 0xc35, 0xc36, 0xc37, 0xc38, 0xc39, 0xc3d, 0xc3e, 0xc3f, 0xc40, 0xc41, 0xc42, 0xc43, 0xc44, 0xc46, 0xc46, 0xc56, 0xc47, 0xc48, 0xc4a
};
void BM_collation_element_lookup_055(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 0, cps_055 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 1, cps_055 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 2, cps_055 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 3, cps_055 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 4, cps_055 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 5, cps_055 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 6, cps_055 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 7, cps_055 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 8, cps_055 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 9, cps_055 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 10, cps_055 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 11, cps_055 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 12, cps_055 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 13, cps_055 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 14, cps_055 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 15, cps_055 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 16, cps_055 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 17, cps_055 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 18, cps_055 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 19, cps_055 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 20, cps_055 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 21, cps_055 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 22, cps_055 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 23, cps_055 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 24, cps_055 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 25, cps_055 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 26, cps_055 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 27, cps_055 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 28, cps_055 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 29, cps_055 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 30, cps_055 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 31, cps_055 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 32, cps_055 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 33, cps_055 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 34, cps_055 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 35, cps_055 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 36, cps_055 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 37, cps_055 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 38, cps_055 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 39, cps_055 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 40, cps_055 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 41, cps_055 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 42, cps_055 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 43, cps_055 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 44, cps_055 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 45, cps_055 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 46, cps_055 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 48, cps_055 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 49, cps_055 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_055 + 50, cps_055 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_055);
uint32_t cps_056[] = {
0xc4b, 0xc4c, 0xc4d, 0xc55, 0xc56, 0xc58, 0xc59, 0xc5a, 0xc60, 0xc61, 0xc62, 0xc63, 0xc66, 0xc67, 0xc68, 0xc69, 0xc6a, 0xc6b, 0xc6c, 0xc6d, 0xc6e, 0xc6f, 0xc78, 0xc79, 0xc7a, 0xc7b, 0xc7c, 0xc7d, 0xc7e, 0xc7f, 0xc80, 0xc81, 0xc82, 0xc83, 0xc85, 0xc86, 0xc87, 0xc88, 0xc89, 0xc8a, 0xc8b, 0xc8c, 0xc8e, 0xc8f, 0xc90, 0xc92, 0xc93, 0xc94, 0xc95, 0xc96
};
void BM_collation_element_lookup_056(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 0, cps_056 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 1, cps_056 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 2, cps_056 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 3, cps_056 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 4, cps_056 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 5, cps_056 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 6, cps_056 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 7, cps_056 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 8, cps_056 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 9, cps_056 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 10, cps_056 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 11, cps_056 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 12, cps_056 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 13, cps_056 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 14, cps_056 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 15, cps_056 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 16, cps_056 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 17, cps_056 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 18, cps_056 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 19, cps_056 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 20, cps_056 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 21, cps_056 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 22, cps_056 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 23, cps_056 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 24, cps_056 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 25, cps_056 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 26, cps_056 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 27, cps_056 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 28, cps_056 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 29, cps_056 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 30, cps_056 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 31, cps_056 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 32, cps_056 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 33, cps_056 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 34, cps_056 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 35, cps_056 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 36, cps_056 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 37, cps_056 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 38, cps_056 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 39, cps_056 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 40, cps_056 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 41, cps_056 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 42, cps_056 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 43, cps_056 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 44, cps_056 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 45, cps_056 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 46, cps_056 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 47, cps_056 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 48, cps_056 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_056 + 49, cps_056 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_056);
uint32_t cps_057[] = {
0xc97, 0xc98, 0xc99, 0xc9a, 0xc9b, 0xc9c, 0xc9d, 0xc9e, 0xc9f, 0xca0, 0xca1, 0xca2, 0xca3, 0xca4, 0xca5, 0xca6, 0xca7, 0xca8, 0xcaa, 0xcab, 0xcac, 0xcad, 0xcae, 0xcaf, 0xcb0, 0xcb1, 0xcb2, 0xcb3, 0xcb5, 0xcb6, 0xcb7, 0xcb8, 0xcb9, 0xcbc, 0xcbd, 0xcbe, 0xcbf, 0xcbf, 0xcd5, 0xcc0, 0xcc1, 0xcc2, 0xcc3, 0xcc4, 0xcc6, 0xcc6, 0xcc2, 0xcc6, 0xcc2, 0xcd5, 0xcc6, 0xcd5, 0xcc6, 0xcd6, 0xcc7, 0xcc8
};
void BM_collation_element_lookup_057(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 0, cps_057 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 1, cps_057 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 2, cps_057 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 3, cps_057 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 4, cps_057 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 5, cps_057 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 6, cps_057 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 7, cps_057 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 8, cps_057 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 9, cps_057 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 10, cps_057 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 11, cps_057 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 12, cps_057 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 13, cps_057 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 14, cps_057 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 15, cps_057 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 16, cps_057 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 17, cps_057 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 18, cps_057 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 19, cps_057 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 20, cps_057 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 21, cps_057 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 22, cps_057 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 23, cps_057 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 24, cps_057 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 25, cps_057 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 26, cps_057 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 27, cps_057 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 28, cps_057 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 29, cps_057 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 30, cps_057 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 31, cps_057 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 32, cps_057 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 33, cps_057 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 34, cps_057 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 35, cps_057 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 36, cps_057 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 37, cps_057 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 39, cps_057 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 40, cps_057 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 41, cps_057 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 42, cps_057 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 43, cps_057 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 44, cps_057 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 45, cps_057 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 47, cps_057 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 50, cps_057 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 52, cps_057 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 54, cps_057 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_057 + 55, cps_057 + 56));
}
}
BENCHMARK(BM_collation_element_lookup_057);
uint32_t cps_058[] = {
0xcca, 0xcca, 0xcd5, 0xccb, 0xccc, 0xccd, 0xcd5, 0xcd6, 0xcde, 0xce0, 0xce1, 0xce2, 0xce3, 0xce6, 0xce7, 0xce8, 0xce9, 0xcea, 0xceb, 0xcec, 0xced, 0xcee, 0xcef, 0xcf1, 0xcf2, 0xd00, 0xd01, 0xd02, 0xd03, 0xd05, 0xd06, 0xd07, 0xd08, 0xd09, 0xd0a, 0xd0b, 0xd0c, 0xd0e, 0xd0f, 0xd10, 0xd12, 0xd13, 0xd14, 0xd15, 0xd16, 0xd17, 0xd18, 0xd19, 0xd1a, 0xd1b, 0xd1c
};
void BM_collation_element_lookup_058(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 0, cps_058 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 1, cps_058 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 3, cps_058 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 4, cps_058 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 5, cps_058 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 6, cps_058 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 7, cps_058 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 8, cps_058 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 9, cps_058 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 10, cps_058 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 11, cps_058 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 12, cps_058 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 13, cps_058 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 14, cps_058 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 15, cps_058 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 16, cps_058 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 17, cps_058 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 18, cps_058 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 19, cps_058 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 20, cps_058 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 21, cps_058 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 22, cps_058 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 23, cps_058 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 24, cps_058 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 25, cps_058 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 26, cps_058 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 27, cps_058 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 28, cps_058 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 29, cps_058 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 30, cps_058 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 31, cps_058 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 32, cps_058 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 33, cps_058 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 34, cps_058 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 35, cps_058 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 36, cps_058 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 37, cps_058 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 38, cps_058 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 39, cps_058 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 40, cps_058 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 41, cps_058 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 42, cps_058 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 43, cps_058 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 44, cps_058 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 45, cps_058 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 46, cps_058 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 47, cps_058 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 48, cps_058 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 49, cps_058 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_058 + 50, cps_058 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_058);
uint32_t cps_059[] = {
0xd1d, 0xd1e, 0xd1f, 0xd20, 0xd21, 0xd22, 0xd23, 0xd24, 0xd25, 0xd26, 0xd27, 0xd28, 0xd29, 0xd2a, 0xd2b, 0xd2c, 0xd2d, 0xd2e, 0xd2f, 0xd30, 0xd31, 0xd32, 0xd33, 0xd34, 0xd35, 0xd36, 0xd37, 0xd38, 0xd39, 0xd3a, 0xd3b, 0xd3c, 0xd3d, 0xd3e, 0xd3f, 0xd40, 0xd41, 0xd42, 0xd43, 0xd44, 0xd46, 0xd46, 0xd3e, 0xd46, 0xd57, 0xd47, 0xd47, 0xd3e, 0xd48, 0xd4a, 0xd4b, 0xd4c, 0xd4d
};
void BM_collation_element_lookup_059(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 0, cps_059 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 1, cps_059 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 2, cps_059 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 3, cps_059 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 4, cps_059 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 5, cps_059 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 6, cps_059 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 7, cps_059 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 8, cps_059 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 9, cps_059 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 10, cps_059 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 11, cps_059 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 12, cps_059 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 13, cps_059 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 14, cps_059 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 15, cps_059 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 16, cps_059 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 17, cps_059 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 18, cps_059 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 19, cps_059 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 20, cps_059 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 21, cps_059 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 22, cps_059 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 23, cps_059 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 24, cps_059 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 25, cps_059 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 26, cps_059 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 27, cps_059 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 28, cps_059 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 29, cps_059 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 30, cps_059 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 31, cps_059 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 32, cps_059 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 33, cps_059 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 34, cps_059 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 35, cps_059 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 36, cps_059 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 37, cps_059 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 38, cps_059 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 39, cps_059 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 40, cps_059 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 41, cps_059 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 43, cps_059 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 45, cps_059 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 46, cps_059 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 48, cps_059 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 49, cps_059 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 50, cps_059 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 51, cps_059 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_059 + 52, cps_059 + 53));
}
}
BENCHMARK(BM_collation_element_lookup_059);
uint32_t cps_060[] = {
0xd4e, 0xd4f, 0xd54, 0xd55, 0xd56, 0xd57, 0xd58, 0xd59, 0xd5a, 0xd5b, 0xd5c, 0xd5d, 0xd5e, 0xd5f, 0xd60, 0xd61, 0xd62, 0xd63, 0xd66, 0xd67, 0xd68, 0xd69, 0xd6a, 0xd6b, 0xd6c, 0xd6d, 0xd6e, 0xd6f, 0xd70, 0xd71, 0xd72, 0xd73, 0xd74, 0xd75, 0xd76, 0xd77, 0xd78, 0xd79, 0xd7a, 0xd7b, 0xd7c, 0xd7d, 0xd7e, 0xd7f, 0xd82, 0xd83, 0xd85, 0xd86, 0xd87, 0xd88
};
void BM_collation_element_lookup_060(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 0, cps_060 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 1, cps_060 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 2, cps_060 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 3, cps_060 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 4, cps_060 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 5, cps_060 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 6, cps_060 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 7, cps_060 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 8, cps_060 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 9, cps_060 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 10, cps_060 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 11, cps_060 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 12, cps_060 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 13, cps_060 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 14, cps_060 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 15, cps_060 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 16, cps_060 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 17, cps_060 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 18, cps_060 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 19, cps_060 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 20, cps_060 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 21, cps_060 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 22, cps_060 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 23, cps_060 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 24, cps_060 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 25, cps_060 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 26, cps_060 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 27, cps_060 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 28, cps_060 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 29, cps_060 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 30, cps_060 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 31, cps_060 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 32, cps_060 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 33, cps_060 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 34, cps_060 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 35, cps_060 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 36, cps_060 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 37, cps_060 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 38, cps_060 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 39, cps_060 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 40, cps_060 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 41, cps_060 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 42, cps_060 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 43, cps_060 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 44, cps_060 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 45, cps_060 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 46, cps_060 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 47, cps_060 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 48, cps_060 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_060 + 49, cps_060 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_060);
uint32_t cps_061[] = {
0xd89, 0xd8a, 0xd8b, 0xd8c, 0xd8d, 0xd8e, 0xd8f, 0xd90, 0xd91, 0xd92, 0xd93, 0xd94, 0xd95, 0xd96, 0xd9a, 0xd9b, 0xd9c, 0xd9d, 0xd9e, 0xd9f, 0xda0, 0xda1, 0xda2, 0xda3, 0xda4, 0xda5, 0xda6, 0xda7, 0xda8, 0xda9, 0xdaa, 0xdab, 0xdac, 0xdad, 0xdae, 0xdaf, 0xdb0, 0xdb1, 0xdb3, 0xdb4, 0xdb5, 0xdb6, 0xdb7, 0xdb8, 0xdb9, 0xdba, 0xdbb, 0xdbd, 0xdc0, 0xdc1
};
void BM_collation_element_lookup_061(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 0, cps_061 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 1, cps_061 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 2, cps_061 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 3, cps_061 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 4, cps_061 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 5, cps_061 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 6, cps_061 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 7, cps_061 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 8, cps_061 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 9, cps_061 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 10, cps_061 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 11, cps_061 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 12, cps_061 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 13, cps_061 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 14, cps_061 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 15, cps_061 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 16, cps_061 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 17, cps_061 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 18, cps_061 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 19, cps_061 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 20, cps_061 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 21, cps_061 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 22, cps_061 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 23, cps_061 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 24, cps_061 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 25, cps_061 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 26, cps_061 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 27, cps_061 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 28, cps_061 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 29, cps_061 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 30, cps_061 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 31, cps_061 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 32, cps_061 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 33, cps_061 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 34, cps_061 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 35, cps_061 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 36, cps_061 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 37, cps_061 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 38, cps_061 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 39, cps_061 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 40, cps_061 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 41, cps_061 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 42, cps_061 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 43, cps_061 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 44, cps_061 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 45, cps_061 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 46, cps_061 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 47, cps_061 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 48, cps_061 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_061 + 49, cps_061 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_061);
uint32_t cps_062[] = {
0xdc2, 0xdc3, 0xdc4, 0xdc5, 0xdc6, 0xdca, 0xdcf, 0xdd0, 0xdd1, 0xdd2, 0xdd3, 0xdd4, 0xdd6, 0xdd8, 0xdd9, 0xdd9, 0xdca, 0xdd9, 0xdcf, 0xdd9, 0xdcf, 0xdca, 0xdd9, 0xddf, 0xdda, 0xddb, 0xddc, 0xddc, 0xdca, 0xddd, 0xdde, 0xddf, 0xde6, 0xde7, 0xde8, 0xde9, 0xdea, 0xdeb, 0xdec, 0xded, 0xdee, 0xdef, 0xdf2, 0xdf3, 0xdf4, 0xe01, 0xe02, 0xe03, 0xe04, 0xe05, 0xe06, 0xe07, 0xe08, 0xe09, 0xe0a, 0xe0b
};
void BM_collation_element_lookup_062(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 0, cps_062 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 1, cps_062 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 2, cps_062 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 3, cps_062 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 4, cps_062 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 5, cps_062 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 6, cps_062 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 7, cps_062 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 8, cps_062 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 9, cps_062 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 10, cps_062 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 11, cps_062 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 12, cps_062 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 13, cps_062 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 14, cps_062 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 15, cps_062 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 17, cps_062 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 19, cps_062 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 22, cps_062 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 24, cps_062 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 25, cps_062 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 26, cps_062 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 27, cps_062 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 29, cps_062 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 30, cps_062 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 31, cps_062 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 32, cps_062 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 33, cps_062 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 34, cps_062 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 35, cps_062 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 36, cps_062 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 37, cps_062 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 38, cps_062 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 39, cps_062 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 40, cps_062 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 41, cps_062 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 42, cps_062 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 43, cps_062 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 44, cps_062 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 45, cps_062 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 46, cps_062 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 47, cps_062 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 48, cps_062 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 49, cps_062 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 50, cps_062 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 51, cps_062 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 52, cps_062 + 53));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 53, cps_062 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 54, cps_062 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_062 + 55, cps_062 + 56));
}
}
BENCHMARK(BM_collation_element_lookup_062);
uint32_t cps_063[] = {
0xe0c, 0xe0d, 0xe0e, 0xe0f, 0xe10, 0xe11, 0xe12, 0xe13, 0xe14, 0xe15, 0xe16, 0xe17, 0xe18, 0xe19, 0xe1a, 0xe1b, 0xe1c, 0xe1d, 0xe1e, 0xe1f, 0xe20, 0xe21, 0xe22, 0xe23, 0xe24, 0xe25, 0xe26, 0xe27, 0xe28, 0xe29, 0xe2a, 0xe2b, 0xe2c, 0xe2d, 0xe2e, 0xe2f, 0xe30, 0xe31, 0xe32, 0xe33, 0xe34, 0xe35, 0xe36, 0xe37, 0xe38, 0xe39, 0xe3a, 0xe3f, 0xe40, 0xe40, 0xe01
};
void BM_collation_element_lookup_063(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 0, cps_063 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 1, cps_063 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 2, cps_063 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 3, cps_063 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 4, cps_063 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 5, cps_063 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 6, cps_063 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 7, cps_063 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 8, cps_063 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 9, cps_063 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 10, cps_063 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 11, cps_063 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 12, cps_063 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 13, cps_063 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 14, cps_063 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 15, cps_063 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 16, cps_063 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 17, cps_063 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 18, cps_063 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 19, cps_063 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 20, cps_063 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 21, cps_063 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 22, cps_063 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 23, cps_063 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 24, cps_063 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 25, cps_063 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 26, cps_063 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 27, cps_063 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 28, cps_063 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 29, cps_063 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 30, cps_063 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 31, cps_063 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 32, cps_063 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 33, cps_063 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 34, cps_063 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 35, cps_063 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 36, cps_063 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 37, cps_063 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 38, cps_063 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 39, cps_063 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 40, cps_063 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 41, cps_063 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 42, cps_063 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 43, cps_063 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 44, cps_063 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 45, cps_063 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 46, cps_063 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 47, cps_063 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 48, cps_063 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_063 + 49, cps_063 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_063);
uint32_t cps_064[] = {
0xe40, 0xe02, 0xe40, 0xe03, 0xe40, 0xe04, 0xe40, 0xe05, 0xe40, 0xe06, 0xe40, 0xe07, 0xe40, 0xe08, 0xe40, 0xe09, 0xe40, 0xe0a, 0xe40, 0xe0b, 0xe40, 0xe0c, 0xe40, 0xe0d, 0xe40, 0xe0e, 0xe40, 0xe0f, 0xe40, 0xe10, 0xe40, 0xe11, 0xe40, 0xe12, 0xe40, 0xe13, 0xe40, 0xe14, 0xe40, 0xe15, 0xe40, 0xe16, 0xe40, 0xe17, 0xe40, 0xe18, 0xe40, 0xe19, 0xe40, 0xe1a, 0xe40, 0xe1b, 0xe40, 0xe1c, 0xe40, 0xe1d, 0xe40, 0xe1e, 0xe40, 0xe1f, 0xe40, 0xe20, 0xe40, 0xe21, 0xe40, 0xe22, 0xe40, 0xe23, 0xe40, 0xe24, 0xe40, 0xe25, 0xe40, 0xe26, 0xe40, 0xe27, 0xe40, 0xe28, 0xe40, 0xe29, 0xe40, 0xe2a, 0xe40, 0xe2b, 0xe40, 0xe2c, 0xe40, 0xe2d, 0xe40, 0xe2e, 0xe41, 0xe41, 0xe01, 0xe41, 0xe02, 0xe41, 0xe03, 0xe41, 0xe04
};
void BM_collation_element_lookup_064(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 0, cps_064 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 2, cps_064 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 4, cps_064 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 6, cps_064 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 8, cps_064 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 10, cps_064 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 12, cps_064 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 14, cps_064 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 16, cps_064 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 18, cps_064 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 20, cps_064 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 22, cps_064 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 24, cps_064 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 26, cps_064 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 28, cps_064 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 30, cps_064 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 32, cps_064 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 34, cps_064 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 36, cps_064 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 38, cps_064 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 40, cps_064 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 42, cps_064 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 44, cps_064 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 46, cps_064 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 48, cps_064 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 50, cps_064 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 52, cps_064 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 54, cps_064 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 56, cps_064 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 58, cps_064 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 60, cps_064 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 62, cps_064 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 64, cps_064 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 66, cps_064 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 68, cps_064 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 70, cps_064 + 72));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 72, cps_064 + 74));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 74, cps_064 + 76));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 76, cps_064 + 78));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 78, cps_064 + 80));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 80, cps_064 + 82));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 82, cps_064 + 84));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 84, cps_064 + 86));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 86, cps_064 + 88));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 88, cps_064 + 90));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 90, cps_064 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 91, cps_064 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 93, cps_064 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 95, cps_064 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_064 + 97, cps_064 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_064);
uint32_t cps_065[] = {
0xe41, 0xe05, 0xe41, 0xe06, 0xe41, 0xe07, 0xe41, 0xe08, 0xe41, 0xe09, 0xe41, 0xe0a, 0xe41, 0xe0b, 0xe41, 0xe0c, 0xe41, 0xe0d, 0xe41, 0xe0e, 0xe41, 0xe0f, 0xe41, 0xe10, 0xe41, 0xe11, 0xe41, 0xe12, 0xe41, 0xe13, 0xe41, 0xe14, 0xe41, 0xe15, 0xe41, 0xe16, 0xe41, 0xe17, 0xe41, 0xe18, 0xe41, 0xe19, 0xe41, 0xe1a, 0xe41, 0xe1b, 0xe41, 0xe1c, 0xe41, 0xe1d, 0xe41, 0xe1e, 0xe41, 0xe1f, 0xe41, 0xe20, 0xe41, 0xe21, 0xe41, 0xe22, 0xe41, 0xe23, 0xe41, 0xe24, 0xe41, 0xe25, 0xe41, 0xe26, 0xe41, 0xe27, 0xe41, 0xe28, 0xe41, 0xe29, 0xe41, 0xe2a, 0xe41, 0xe2b, 0xe41, 0xe2c, 0xe41, 0xe2d, 0xe41, 0xe2e, 0xe42, 0xe42, 0xe01, 0xe42, 0xe02, 0xe42, 0xe03, 0xe42, 0xe04, 0xe42, 0xe05, 0xe42, 0xe06, 0xe42, 0xe07
};
void BM_collation_element_lookup_065(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 0, cps_065 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 2, cps_065 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 4, cps_065 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 6, cps_065 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 8, cps_065 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 10, cps_065 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 12, cps_065 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 14, cps_065 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 16, cps_065 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 18, cps_065 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 20, cps_065 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 22, cps_065 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 24, cps_065 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 26, cps_065 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 28, cps_065 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 30, cps_065 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 32, cps_065 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 34, cps_065 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 36, cps_065 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 38, cps_065 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 40, cps_065 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 42, cps_065 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 44, cps_065 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 46, cps_065 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 48, cps_065 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 50, cps_065 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 52, cps_065 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 54, cps_065 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 56, cps_065 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 58, cps_065 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 60, cps_065 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 62, cps_065 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 64, cps_065 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 66, cps_065 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 68, cps_065 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 70, cps_065 + 72));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 72, cps_065 + 74));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 74, cps_065 + 76));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 76, cps_065 + 78));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 78, cps_065 + 80));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 80, cps_065 + 82));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 82, cps_065 + 84));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 84, cps_065 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 85, cps_065 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 87, cps_065 + 89));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 89, cps_065 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 91, cps_065 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 93, cps_065 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 95, cps_065 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_065 + 97, cps_065 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_065);
uint32_t cps_066[] = {
0xe42, 0xe08, 0xe42, 0xe09, 0xe42, 0xe0a, 0xe42, 0xe0b, 0xe42, 0xe0c, 0xe42, 0xe0d, 0xe42, 0xe0e, 0xe42, 0xe0f, 0xe42, 0xe10, 0xe42, 0xe11, 0xe42, 0xe12, 0xe42, 0xe13, 0xe42, 0xe14, 0xe42, 0xe15, 0xe42, 0xe16, 0xe42, 0xe17, 0xe42, 0xe18, 0xe42, 0xe19, 0xe42, 0xe1a, 0xe42, 0xe1b, 0xe42, 0xe1c, 0xe42, 0xe1d, 0xe42, 0xe1e, 0xe42, 0xe1f, 0xe42, 0xe20, 0xe42, 0xe21, 0xe42, 0xe22, 0xe42, 0xe23, 0xe42, 0xe24, 0xe42, 0xe25, 0xe42, 0xe26, 0xe42, 0xe27, 0xe42, 0xe28, 0xe42, 0xe29, 0xe42, 0xe2a, 0xe42, 0xe2b, 0xe42, 0xe2c, 0xe42, 0xe2d, 0xe42, 0xe2e, 0xe43, 0xe43, 0xe01, 0xe43, 0xe02, 0xe43, 0xe03, 0xe43, 0xe04, 0xe43, 0xe05, 0xe43, 0xe06, 0xe43, 0xe07, 0xe43, 0xe08, 0xe43, 0xe09, 0xe43, 0xe0a
};
void BM_collation_element_lookup_066(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 0, cps_066 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 2, cps_066 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 4, cps_066 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 6, cps_066 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 8, cps_066 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 10, cps_066 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 12, cps_066 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 14, cps_066 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 16, cps_066 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 18, cps_066 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 20, cps_066 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 22, cps_066 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 24, cps_066 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 26, cps_066 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 28, cps_066 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 30, cps_066 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 32, cps_066 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 34, cps_066 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 36, cps_066 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 38, cps_066 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 40, cps_066 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 42, cps_066 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 44, cps_066 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 46, cps_066 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 48, cps_066 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 50, cps_066 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 52, cps_066 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 54, cps_066 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 56, cps_066 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 58, cps_066 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 60, cps_066 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 62, cps_066 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 64, cps_066 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 66, cps_066 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 68, cps_066 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 70, cps_066 + 72));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 72, cps_066 + 74));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 74, cps_066 + 76));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 76, cps_066 + 78));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 78, cps_066 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 79, cps_066 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 81, cps_066 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 83, cps_066 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 85, cps_066 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 87, cps_066 + 89));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 89, cps_066 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 91, cps_066 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 93, cps_066 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 95, cps_066 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_066 + 97, cps_066 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_066);
uint32_t cps_067[] = {
0xe43, 0xe0b, 0xe43, 0xe0c, 0xe43, 0xe0d, 0xe43, 0xe0e, 0xe43, 0xe0f, 0xe43, 0xe10, 0xe43, 0xe11, 0xe43, 0xe12, 0xe43, 0xe13, 0xe43, 0xe14, 0xe43, 0xe15, 0xe43, 0xe16, 0xe43, 0xe17, 0xe43, 0xe18, 0xe43, 0xe19, 0xe43, 0xe1a, 0xe43, 0xe1b, 0xe43, 0xe1c, 0xe43, 0xe1d, 0xe43, 0xe1e, 0xe43, 0xe1f, 0xe43, 0xe20, 0xe43, 0xe21, 0xe43, 0xe22, 0xe43, 0xe23, 0xe43, 0xe24, 0xe43, 0xe25, 0xe43, 0xe26, 0xe43, 0xe27, 0xe43, 0xe28, 0xe43, 0xe29, 0xe43, 0xe2a, 0xe43, 0xe2b, 0xe43, 0xe2c, 0xe43, 0xe2d, 0xe43, 0xe2e, 0xe44, 0xe44, 0xe01, 0xe44, 0xe02, 0xe44, 0xe03, 0xe44, 0xe04, 0xe44, 0xe05, 0xe44, 0xe06, 0xe44, 0xe07, 0xe44, 0xe08, 0xe44, 0xe09, 0xe44, 0xe0a, 0xe44, 0xe0b, 0xe44, 0xe0c, 0xe44, 0xe0d
};
void BM_collation_element_lookup_067(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 0, cps_067 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 2, cps_067 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 4, cps_067 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 6, cps_067 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 8, cps_067 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 10, cps_067 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 12, cps_067 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 14, cps_067 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 16, cps_067 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 18, cps_067 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 20, cps_067 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 22, cps_067 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 24, cps_067 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 26, cps_067 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 28, cps_067 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 30, cps_067 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 32, cps_067 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 34, cps_067 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 36, cps_067 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 38, cps_067 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 40, cps_067 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 42, cps_067 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 44, cps_067 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 46, cps_067 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 48, cps_067 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 50, cps_067 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 52, cps_067 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 54, cps_067 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 56, cps_067 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 58, cps_067 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 60, cps_067 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 62, cps_067 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 64, cps_067 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 66, cps_067 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 68, cps_067 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 70, cps_067 + 72));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 72, cps_067 + 73));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 73, cps_067 + 75));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 75, cps_067 + 77));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 77, cps_067 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 79, cps_067 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 81, cps_067 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 83, cps_067 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 85, cps_067 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 87, cps_067 + 89));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 89, cps_067 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 91, cps_067 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 93, cps_067 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 95, cps_067 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_067 + 97, cps_067 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_067);
uint32_t cps_068[] = {
0xe44, 0xe0e, 0xe44, 0xe0f, 0xe44, 0xe10, 0xe44, 0xe11, 0xe44, 0xe12, 0xe44, 0xe13, 0xe44, 0xe14, 0xe44, 0xe15, 0xe44, 0xe16, 0xe44, 0xe17, 0xe44, 0xe18, 0xe44, 0xe19, 0xe44, 0xe1a, 0xe44, 0xe1b, 0xe44, 0xe1c, 0xe44, 0xe1d, 0xe44, 0xe1e, 0xe44, 0xe1f, 0xe44, 0xe20, 0xe44, 0xe21, 0xe44, 0xe22, 0xe44, 0xe23, 0xe44, 0xe24, 0xe44, 0xe25, 0xe44, 0xe26, 0xe44, 0xe27, 0xe44, 0xe28, 0xe44, 0xe29, 0xe44, 0xe2a, 0xe44, 0xe2b, 0xe44, 0xe2c, 0xe44, 0xe2d, 0xe44, 0xe2e, 0xe45, 0xe46, 0xe47, 0xe48, 0xe49, 0xe4a, 0xe4b, 0xe4c, 0xe4d, 0xe4d, 0xe32, 0xe4e, 0xe4f, 0xe50, 0xe51, 0xe52, 0xe53, 0xe54
};
void BM_collation_element_lookup_068(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 0, cps_068 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 2, cps_068 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 4, cps_068 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 6, cps_068 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 8, cps_068 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 10, cps_068 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 12, cps_068 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 14, cps_068 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 16, cps_068 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 18, cps_068 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 20, cps_068 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 22, cps_068 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 24, cps_068 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 26, cps_068 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 28, cps_068 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 30, cps_068 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 32, cps_068 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 34, cps_068 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 36, cps_068 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 38, cps_068 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 40, cps_068 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 42, cps_068 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 44, cps_068 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 46, cps_068 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 48, cps_068 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 50, cps_068 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 52, cps_068 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 54, cps_068 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 56, cps_068 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 58, cps_068 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 60, cps_068 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 62, cps_068 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 64, cps_068 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 66, cps_068 + 67));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 67, cps_068 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 68, cps_068 + 69));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 69, cps_068 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 70, cps_068 + 71));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 71, cps_068 + 72));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 72, cps_068 + 73));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 73, cps_068 + 74));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 74, cps_068 + 75));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 75, cps_068 + 77));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 77, cps_068 + 78));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 78, cps_068 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 79, cps_068 + 80));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 80, cps_068 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 81, cps_068 + 82));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 82, cps_068 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_068 + 83, cps_068 + 84));
}
}
BENCHMARK(BM_collation_element_lookup_068);
uint32_t cps_069[] = {
0xe55, 0xe56, 0xe57, 0xe58, 0xe59, 0xe5a, 0xe5b, 0xe81, 0xe82, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8d, 0xe94, 0xe95, 0xe96, 0xe97, 0xe99, 0xe9a, 0xe9b, 0xe9c, 0xe9d, 0xe9e, 0xe9f, 0xea1, 0xea2, 0xea3, 0xea5, 0xea7, 0xeaa, 0xeab, 0xead, 0xeae, 0xeaf, 0xeb0, 0xeb1, 0xeb2, 0xeb3, 0xeb4, 0xeb5, 0xeb6, 0xeb7, 0xeb8, 0xeb9, 0xebb, 0xebc, 0xebd, 0xec0, 0xec0, 0xe81
};
void BM_collation_element_lookup_069(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 0, cps_069 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 1, cps_069 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 2, cps_069 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 3, cps_069 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 4, cps_069 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 5, cps_069 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 6, cps_069 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 7, cps_069 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 8, cps_069 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 9, cps_069 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 10, cps_069 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 11, cps_069 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 12, cps_069 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 13, cps_069 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 14, cps_069 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 15, cps_069 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 16, cps_069 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 17, cps_069 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 18, cps_069 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 19, cps_069 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 20, cps_069 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 21, cps_069 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 22, cps_069 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 23, cps_069 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 24, cps_069 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 25, cps_069 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 26, cps_069 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 27, cps_069 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 28, cps_069 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 29, cps_069 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 30, cps_069 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 31, cps_069 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 32, cps_069 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 33, cps_069 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 34, cps_069 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 35, cps_069 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 36, cps_069 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 37, cps_069 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 38, cps_069 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 39, cps_069 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 40, cps_069 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 41, cps_069 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 42, cps_069 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 43, cps_069 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 44, cps_069 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 45, cps_069 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 46, cps_069 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 47, cps_069 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 48, cps_069 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_069 + 49, cps_069 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_069);
uint32_t cps_070[] = {
0xec0, 0xe82, 0xec0, 0xe84, 0xec0, 0xe87, 0xec0, 0xe88, 0xec0, 0xe8a, 0xec0, 0xe8d, 0xec0, 0xe94, 0xec0, 0xe95, 0xec0, 0xe96, 0xec0, 0xe97, 0xec0, 0xe99, 0xec0, 0xe9a, 0xec0, 0xe9b, 0xec0, 0xe9c, 0xec0, 0xe9d, 0xec0, 0xe9e, 0xec0, 0xe9f, 0xec0, 0xea1, 0xec0, 0xea2, 0xec0, 0xea3, 0xec0, 0xea5, 0xec0, 0xea7, 0xec0, 0xeaa, 0xec0, 0xeab, 0xec0, 0xead, 0xec0, 0xeae, 0xec0, 0xedc, 0xec0, 0xedd, 0xec0, 0xede, 0xec0, 0xedf, 0xec1, 0xec1, 0xe81, 0xec1, 0xe82, 0xec1, 0xe84, 0xec1, 0xe87, 0xec1, 0xe88, 0xec1, 0xe8a, 0xec1, 0xe8d, 0xec1, 0xe94, 0xec1, 0xe95, 0xec1, 0xe96, 0xec1, 0xe97, 0xec1, 0xe99, 0xec1, 0xe9a, 0xec1, 0xe9b, 0xec1, 0xe9c, 0xec1, 0xe9d, 0xec1, 0xe9e, 0xec1, 0xe9f, 0xec1, 0xea1
};
void BM_collation_element_lookup_070(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 0, cps_070 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 2, cps_070 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 4, cps_070 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 6, cps_070 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 8, cps_070 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 10, cps_070 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 12, cps_070 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 14, cps_070 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 16, cps_070 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 18, cps_070 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 20, cps_070 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 22, cps_070 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 24, cps_070 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 26, cps_070 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 28, cps_070 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 30, cps_070 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 32, cps_070 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 34, cps_070 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 36, cps_070 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 38, cps_070 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 40, cps_070 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 42, cps_070 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 44, cps_070 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 46, cps_070 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 48, cps_070 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 50, cps_070 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 52, cps_070 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 54, cps_070 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 56, cps_070 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 58, cps_070 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 60, cps_070 + 61));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 61, cps_070 + 63));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 63, cps_070 + 65));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 65, cps_070 + 67));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 67, cps_070 + 69));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 69, cps_070 + 71));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 71, cps_070 + 73));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 73, cps_070 + 75));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 75, cps_070 + 77));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 77, cps_070 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 79, cps_070 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 81, cps_070 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 83, cps_070 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 85, cps_070 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 87, cps_070 + 89));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 89, cps_070 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 91, cps_070 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 93, cps_070 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 95, cps_070 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_070 + 97, cps_070 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_070);
uint32_t cps_071[] = {
0xec1, 0xea2, 0xec1, 0xea3, 0xec1, 0xea5, 0xec1, 0xea7, 0xec1, 0xeaa, 0xec1, 0xeab, 0xec1, 0xead, 0xec1, 0xeae, 0xec1, 0xedc, 0xec1, 0xedd, 0xec1, 0xede, 0xec1, 0xedf, 0xec2, 0xec2, 0xe81, 0xec2, 0xe82, 0xec2, 0xe84, 0xec2, 0xe87, 0xec2, 0xe88, 0xec2, 0xe8a, 0xec2, 0xe8d, 0xec2, 0xe94, 0xec2, 0xe95, 0xec2, 0xe96, 0xec2, 0xe97, 0xec2, 0xe99, 0xec2, 0xe9a, 0xec2, 0xe9b, 0xec2, 0xe9c, 0xec2, 0xe9d, 0xec2, 0xe9e, 0xec2, 0xe9f, 0xec2, 0xea1, 0xec2, 0xea2, 0xec2, 0xea3, 0xec2, 0xea5, 0xec2, 0xea7, 0xec2, 0xeaa, 0xec2, 0xeab, 0xec2, 0xead, 0xec2, 0xeae, 0xec2, 0xedc, 0xec2, 0xedd, 0xec2, 0xede, 0xec2, 0xedf, 0xec3, 0xec3, 0xe81, 0xec3, 0xe82, 0xec3, 0xe84, 0xec3, 0xe87, 0xec3, 0xe88
};
void BM_collation_element_lookup_071(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 0, cps_071 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 2, cps_071 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 4, cps_071 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 6, cps_071 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 8, cps_071 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 10, cps_071 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 12, cps_071 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 14, cps_071 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 16, cps_071 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 18, cps_071 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 20, cps_071 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 22, cps_071 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 24, cps_071 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 25, cps_071 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 27, cps_071 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 29, cps_071 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 31, cps_071 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 33, cps_071 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 35, cps_071 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 37, cps_071 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 39, cps_071 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 41, cps_071 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 43, cps_071 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 45, cps_071 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 47, cps_071 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 49, cps_071 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 51, cps_071 + 53));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 53, cps_071 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 55, cps_071 + 57));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 57, cps_071 + 59));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 59, cps_071 + 61));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 61, cps_071 + 63));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 63, cps_071 + 65));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 65, cps_071 + 67));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 67, cps_071 + 69));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 69, cps_071 + 71));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 71, cps_071 + 73));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 73, cps_071 + 75));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 75, cps_071 + 77));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 77, cps_071 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 79, cps_071 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 81, cps_071 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 83, cps_071 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 85, cps_071 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 87, cps_071 + 88));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 88, cps_071 + 90));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 90, cps_071 + 92));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 92, cps_071 + 94));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 94, cps_071 + 96));
benchmark::DoNotOptimize(trie().longest_match(cps_071 + 96, cps_071 + 98));
}
}
BENCHMARK(BM_collation_element_lookup_071);
uint32_t cps_072[] = {
0xec3, 0xe8a, 0xec3, 0xe8d, 0xec3, 0xe94, 0xec3, 0xe95, 0xec3, 0xe96, 0xec3, 0xe97, 0xec3, 0xe99, 0xec3, 0xe9a, 0xec3, 0xe9b, 0xec3, 0xe9c, 0xec3, 0xe9d, 0xec3, 0xe9e, 0xec3, 0xe9f, 0xec3, 0xea1, 0xec3, 0xea2, 0xec3, 0xea3, 0xec3, 0xea5, 0xec3, 0xea7, 0xec3, 0xeaa, 0xec3, 0xeab, 0xec3, 0xead, 0xec3, 0xeae, 0xec3, 0xedc, 0xec3, 0xedd, 0xec3, 0xede, 0xec3, 0xedf, 0xec4, 0xec4, 0xe81, 0xec4, 0xe82, 0xec4, 0xe84, 0xec4, 0xe87, 0xec4, 0xe88, 0xec4, 0xe8a, 0xec4, 0xe8d, 0xec4, 0xe94, 0xec4, 0xe95, 0xec4, 0xe96, 0xec4, 0xe97, 0xec4, 0xe99, 0xec4, 0xe9a, 0xec4, 0xe9b, 0xec4, 0xe9c, 0xec4, 0xe9d, 0xec4, 0xe9e, 0xec4, 0xe9f, 0xec4, 0xea1, 0xec4, 0xea2, 0xec4, 0xea3, 0xec4, 0xea5, 0xec4, 0xea7
};
void BM_collation_element_lookup_072(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 0, cps_072 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 2, cps_072 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 4, cps_072 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 6, cps_072 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 8, cps_072 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 10, cps_072 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 12, cps_072 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 14, cps_072 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 16, cps_072 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 18, cps_072 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 20, cps_072 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 22, cps_072 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 24, cps_072 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 26, cps_072 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 28, cps_072 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 30, cps_072 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 32, cps_072 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 34, cps_072 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 36, cps_072 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 38, cps_072 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 40, cps_072 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 42, cps_072 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 44, cps_072 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 46, cps_072 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 48, cps_072 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 50, cps_072 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 52, cps_072 + 53));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 53, cps_072 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 55, cps_072 + 57));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 57, cps_072 + 59));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 59, cps_072 + 61));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 61, cps_072 + 63));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 63, cps_072 + 65));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 65, cps_072 + 67));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 67, cps_072 + 69));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 69, cps_072 + 71));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 71, cps_072 + 73));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 73, cps_072 + 75));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 75, cps_072 + 77));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 77, cps_072 + 79));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 79, cps_072 + 81));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 81, cps_072 + 83));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 83, cps_072 + 85));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 85, cps_072 + 87));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 87, cps_072 + 89));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 89, cps_072 + 91));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 91, cps_072 + 93));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 93, cps_072 + 95));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 95, cps_072 + 97));
benchmark::DoNotOptimize(trie().longest_match(cps_072 + 97, cps_072 + 99));
}
}
BENCHMARK(BM_collation_element_lookup_072);
uint32_t cps_073[] = {
0xec4, 0xeaa, 0xec4, 0xeab, 0xec4, 0xead, 0xec4, 0xeae, 0xec4, 0xedc, 0xec4, 0xedd, 0xec4, 0xede, 0xec4, 0xedf, 0xec6, 0xec8, 0xec9, 0xeca, 0xecb, 0xecc, 0xecd, 0xecd, 0xeb2, 0xed0, 0xed1, 0xed2, 0xed3, 0xed4, 0xed5, 0xed6, 0xed7, 0xed8, 0xed9, 0xedc, 0xedd, 0xede, 0xedf, 0xf00, 0xf01, 0xf02, 0xf03, 0xf04, 0xf05, 0xf06, 0xf07, 0xf08, 0xf09, 0xf0a, 0xf0b, 0xf0c, 0xf0d, 0xf0e, 0xf0f, 0xf10, 0xf11, 0xf12, 0xf13
};
void BM_collation_element_lookup_073(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 0, cps_073 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 2, cps_073 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 4, cps_073 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 6, cps_073 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 8, cps_073 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 10, cps_073 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 12, cps_073 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 14, cps_073 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 16, cps_073 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 17, cps_073 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 18, cps_073 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 19, cps_073 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 20, cps_073 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 21, cps_073 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 22, cps_073 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 23, cps_073 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 25, cps_073 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 26, cps_073 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 27, cps_073 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 28, cps_073 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 29, cps_073 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 30, cps_073 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 31, cps_073 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 32, cps_073 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 33, cps_073 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 34, cps_073 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 35, cps_073 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 36, cps_073 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 37, cps_073 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 38, cps_073 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 39, cps_073 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 40, cps_073 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 41, cps_073 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 42, cps_073 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 43, cps_073 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 44, cps_073 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 45, cps_073 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 46, cps_073 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 47, cps_073 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 48, cps_073 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 49, cps_073 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 50, cps_073 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 51, cps_073 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 52, cps_073 + 53));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 53, cps_073 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 54, cps_073 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 55, cps_073 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 56, cps_073 + 57));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 57, cps_073 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_073 + 58, cps_073 + 59));
}
}
BENCHMARK(BM_collation_element_lookup_073);
uint32_t cps_074[] = {
0xf14, 0xf15, 0xf16, 0xf17, 0xf18, 0xf19, 0xf1a, 0xf1b, 0xf1c, 0xf1d, 0xf1e, 0xf1f, 0xf20, 0xf21, 0xf22, 0xf23, 0xf24, 0xf25, 0xf26, 0xf27, 0xf28, 0xf29, 0xf2a, 0xf2b, 0xf2c, 0xf2d, 0xf2e, 0xf2f, 0xf30, 0xf31, 0xf32, 0xf33, 0xf34, 0xf35, 0xf36, 0xf37, 0xf38, 0xf39, 0xf3a, 0xf3b, 0xf3c, 0xf3d, 0xf3e, 0xf3f, 0xf40, 0xf41, 0xf42, 0xf43, 0xf44, 0xf45
};
void BM_collation_element_lookup_074(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 0, cps_074 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 1, cps_074 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 2, cps_074 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 3, cps_074 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 4, cps_074 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 5, cps_074 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 6, cps_074 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 7, cps_074 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 8, cps_074 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 9, cps_074 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 10, cps_074 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 11, cps_074 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 12, cps_074 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 13, cps_074 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 14, cps_074 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 15, cps_074 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 16, cps_074 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 17, cps_074 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 18, cps_074 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 19, cps_074 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 20, cps_074 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 21, cps_074 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 22, cps_074 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 23, cps_074 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 24, cps_074 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 25, cps_074 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 26, cps_074 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 27, cps_074 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 28, cps_074 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 29, cps_074 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 30, cps_074 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 31, cps_074 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 32, cps_074 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 33, cps_074 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 34, cps_074 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 35, cps_074 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 36, cps_074 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 37, cps_074 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 38, cps_074 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 39, cps_074 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 40, cps_074 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 41, cps_074 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 42, cps_074 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 43, cps_074 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 44, cps_074 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 45, cps_074 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 46, cps_074 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 47, cps_074 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 48, cps_074 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_074 + 49, cps_074 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_074);
uint32_t cps_075[] = {
0xf46, 0xf47, 0xf49, 0xf4a, 0xf4b, 0xf4c, 0xf4d, 0xf4e, 0xf4f, 0xf50, 0xf51, 0xf52, 0xf53, 0xf54, 0xf55, 0xf56, 0xf57, 0xf58, 0xf59, 0xf5a, 0xf5b, 0xf5c, 0xf5d, 0xf5e, 0xf5f, 0xf60, 0xf61, 0xf62, 0xf63, 0xf64, 0xf65, 0xf66, 0xf67, 0xf68, 0xf69, 0xf6a, 0xf6b, 0xf6c, 0xf71, 0xf71, 0xf72, 0xf71, 0xf74, 0xf71, 0xf80, 0xf72, 0xf73, 0xf74, 0xf75, 0xf76, 0xf77, 0xf78, 0xf79
};
void BM_collation_element_lookup_075(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 0, cps_075 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 1, cps_075 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 2, cps_075 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 3, cps_075 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 4, cps_075 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 5, cps_075 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 6, cps_075 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 7, cps_075 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 8, cps_075 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 9, cps_075 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 10, cps_075 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 11, cps_075 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 12, cps_075 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 13, cps_075 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 14, cps_075 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 15, cps_075 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 16, cps_075 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 17, cps_075 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 18, cps_075 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 19, cps_075 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 20, cps_075 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 21, cps_075 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 22, cps_075 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 23, cps_075 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 24, cps_075 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 25, cps_075 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 26, cps_075 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 27, cps_075 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 28, cps_075 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 29, cps_075 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 30, cps_075 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 31, cps_075 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 32, cps_075 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 33, cps_075 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 34, cps_075 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 35, cps_075 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 36, cps_075 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 37, cps_075 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 38, cps_075 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 39, cps_075 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 41, cps_075 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 43, cps_075 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 45, cps_075 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 46, cps_075 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 47, cps_075 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 48, cps_075 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 49, cps_075 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 50, cps_075 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 51, cps_075 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_075 + 52, cps_075 + 53));
}
}
BENCHMARK(BM_collation_element_lookup_075);
uint32_t cps_076[] = {
0xf7a, 0xf7b, 0xf7c, 0xf7d, 0xf7e, 0xf7f, 0xf80, 0xf81, 0xf82, 0xf83, 0xf84, 0xf85, 0xf86, 0xf87, 0xf88, 0xf89, 0xf8a, 0xf8b, 0xf8c, 0xf8d, 0xf8e, 0xf8f, 0xf90, 0xf91, 0xf92, 0xf93, 0xf94, 0xf95, 0xf96, 0xf97, 0xf99, 0xf9a, 0xf9b, 0xf9c, 0xf9d, 0xf9e, 0xf9f, 0xfa0, 0xfa1, 0xfa2, 0xfa3, 0xfa4, 0xfa5, 0xfa6, 0xfa7, 0xfa8, 0xfa9, 0xfaa, 0xfab, 0xfac
};
void BM_collation_element_lookup_076(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 0, cps_076 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 1, cps_076 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 2, cps_076 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 3, cps_076 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 4, cps_076 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 5, cps_076 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 6, cps_076 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 7, cps_076 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 8, cps_076 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 9, cps_076 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 10, cps_076 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 11, cps_076 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 12, cps_076 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 13, cps_076 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 14, cps_076 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 15, cps_076 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 16, cps_076 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 17, cps_076 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 18, cps_076 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 19, cps_076 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 20, cps_076 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 21, cps_076 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 22, cps_076 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 23, cps_076 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 24, cps_076 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 25, cps_076 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 26, cps_076 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 27, cps_076 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 28, cps_076 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 29, cps_076 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 30, cps_076 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 31, cps_076 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 32, cps_076 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 33, cps_076 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 34, cps_076 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 35, cps_076 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 36, cps_076 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 37, cps_076 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 38, cps_076 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 39, cps_076 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 40, cps_076 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 41, cps_076 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 42, cps_076 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 43, cps_076 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 44, cps_076 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 45, cps_076 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 46, cps_076 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 47, cps_076 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 48, cps_076 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_076 + 49, cps_076 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_076);
uint32_t cps_077[] = {
0xfad, 0xfae, 0xfaf, 0xfb0, 0xfb1, 0xfb2, 0xfb2, 0xf71, 0xfb2, 0xf71, 0xf72, 0xfb2, 0xf71, 0xf74, 0xfb2, 0xf71, 0xf80, 0xfb2, 0xf73, 0xfb2, 0xf75, 0xfb2, 0xf80, 0xfb2, 0xf81, 0xfb3, 0xfb3, 0xf71, 0xfb3, 0xf71, 0xf72, 0xfb3, 0xf71, 0xf74, 0xfb3, 0xf71, 0xf80, 0xfb3, 0xf73, 0xfb3, 0xf75, 0xfb3, 0xf80, 0xfb3, 0xf81, 0xfb4, 0xfb5, 0xfb6, 0xfb7, 0xfb8, 0xfb9, 0xfba, 0xfbb, 0xfbc, 0xfbe, 0xfbf, 0xfc0, 0xfc1, 0xfc2, 0xfc3, 0xfc4, 0xfc5, 0xfc6, 0xfc7, 0xfc8, 0xfc9, 0xfca, 0xfcb, 0xfcc, 0xfce, 0xfcf, 0xfd0
};
void BM_collation_element_lookup_077(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 0, cps_077 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 1, cps_077 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 2, cps_077 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 3, cps_077 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 4, cps_077 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 5, cps_077 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 6, cps_077 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 8, cps_077 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 11, cps_077 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 14, cps_077 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 17, cps_077 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 19, cps_077 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 21, cps_077 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 23, cps_077 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 25, cps_077 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 26, cps_077 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 28, cps_077 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 31, cps_077 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 34, cps_077 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 37, cps_077 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 39, cps_077 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 41, cps_077 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 43, cps_077 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 45, cps_077 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 46, cps_077 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 47, cps_077 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 48, cps_077 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 49, cps_077 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 50, cps_077 + 51));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 51, cps_077 + 52));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 52, cps_077 + 53));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 53, cps_077 + 54));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 54, cps_077 + 55));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 55, cps_077 + 56));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 56, cps_077 + 57));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 57, cps_077 + 58));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 58, cps_077 + 59));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 59, cps_077 + 60));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 60, cps_077 + 61));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 61, cps_077 + 62));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 62, cps_077 + 63));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 63, cps_077 + 64));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 64, cps_077 + 65));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 65, cps_077 + 66));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 66, cps_077 + 67));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 67, cps_077 + 68));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 68, cps_077 + 69));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 69, cps_077 + 70));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 70, cps_077 + 71));
benchmark::DoNotOptimize(trie().longest_match(cps_077 + 71, cps_077 + 72));
}
}
BENCHMARK(BM_collation_element_lookup_077);
uint32_t cps_078[] = {
0xfd1, 0xfd2, 0xfd3, 0xfd4, 0xfd5, 0xfd6, 0xfd7, 0xfd8, 0xfd9, 0xfda, 0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007, 0x1008, 0x1009, 0x100a, 0x100b, 0x100c, 0x100d, 0x100e, 0x100f, 0x1010, 0x1011, 0x1012, 0x1013, 0x1014, 0x1015, 0x1016, 0x1017, 0x1018, 0x1019, 0x101a, 0x101b, 0x101c, 0x101d, 0x101e, 0x101f, 0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1025, 0x102e, 0x1026
};
void BM_collation_element_lookup_078(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 0, cps_078 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 1, cps_078 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 2, cps_078 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 3, cps_078 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 4, cps_078 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 5, cps_078 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 6, cps_078 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 7, cps_078 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 8, cps_078 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 9, cps_078 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 10, cps_078 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 11, cps_078 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 12, cps_078 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 13, cps_078 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 14, cps_078 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 15, cps_078 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 16, cps_078 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 17, cps_078 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 18, cps_078 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 19, cps_078 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 20, cps_078 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 21, cps_078 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 22, cps_078 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 23, cps_078 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 24, cps_078 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 25, cps_078 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 26, cps_078 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 27, cps_078 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 28, cps_078 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 29, cps_078 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 30, cps_078 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 31, cps_078 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 32, cps_078 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 33, cps_078 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 34, cps_078 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 35, cps_078 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 36, cps_078 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 37, cps_078 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 38, cps_078 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 39, cps_078 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 40, cps_078 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 41, cps_078 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 42, cps_078 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 43, cps_078 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 44, cps_078 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 45, cps_078 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 46, cps_078 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 47, cps_078 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 48, cps_078 + 50));
benchmark::DoNotOptimize(trie().longest_match(cps_078 + 50, cps_078 + 51));
}
}
BENCHMARK(BM_collation_element_lookup_078);
uint32_t cps_079[] = {
0x1027, 0x1028, 0x1029, 0x102a, 0x102b, 0x102c, 0x102d, 0x102e, 0x102f, 0x1030, 0x1031, 0x1032, 0x1033, 0x1034, 0x1035, 0x1036, 0x1037, 0x1038, 0x1039, 0x103a, 0x103b, 0x103c, 0x103d, 0x103e, 0x103f, 0x1040, 0x1041, 0x1042, 0x1043, 0x1044, 0x1045, 0x1046, 0x1047, 0x1048, 0x1049, 0x104a, 0x104b, 0x104c, 0x104d, 0x104e, 0x104f, 0x1050, 0x1051, 0x1052, 0x1053, 0x1054, 0x1055, 0x1056, 0x1057, 0x1058
};
void BM_collation_element_lookup_079(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 0, cps_079 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 1, cps_079 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 2, cps_079 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 3, cps_079 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 4, cps_079 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 5, cps_079 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 6, cps_079 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 7, cps_079 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 8, cps_079 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 9, cps_079 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 10, cps_079 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 11, cps_079 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 12, cps_079 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 13, cps_079 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 14, cps_079 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 15, cps_079 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 16, cps_079 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 17, cps_079 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 18, cps_079 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 19, cps_079 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 20, cps_079 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 21, cps_079 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 22, cps_079 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 23, cps_079 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 24, cps_079 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 25, cps_079 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 26, cps_079 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 27, cps_079 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 28, cps_079 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 29, cps_079 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 30, cps_079 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 31, cps_079 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 32, cps_079 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 33, cps_079 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 34, cps_079 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 35, cps_079 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 36, cps_079 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 37, cps_079 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 38, cps_079 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 39, cps_079 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 40, cps_079 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 41, cps_079 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 42, cps_079 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 43, cps_079 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 44, cps_079 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 45, cps_079 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 46, cps_079 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 47, cps_079 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 48, cps_079 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_079 + 49, cps_079 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_079);
uint32_t cps_080[] = {
0x1059, 0x105a, 0x105b, 0x105c, 0x105d, 0x105e, 0x105f, 0x1060, 0x1061, 0x1062, 0x1063, 0x1064, 0x1065, 0x1066, 0x1067, 0x1068, 0x1069, 0x106a, 0x106b, 0x106c, 0x106d, 0x106e, 0x106f, 0x1070, 0x1071, 0x1072, 0x1073, 0x1074, 0x1075, 0x1076, 0x1077, 0x1078, 0x1079, 0x107a, 0x107b, 0x107c, 0x107d, 0x107e, 0x107f, 0x1080, 0x1081, 0x1082, 0x1083, 0x1084, 0x1085, 0x1086, 0x1087, 0x1088, 0x1089, 0x108a
};
void BM_collation_element_lookup_080(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 0, cps_080 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 1, cps_080 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 2, cps_080 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 3, cps_080 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 4, cps_080 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 5, cps_080 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 6, cps_080 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 7, cps_080 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 8, cps_080 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 9, cps_080 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 10, cps_080 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 11, cps_080 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 12, cps_080 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 13, cps_080 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 14, cps_080 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 15, cps_080 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 16, cps_080 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 17, cps_080 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 18, cps_080 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 19, cps_080 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 20, cps_080 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 21, cps_080 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 22, cps_080 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 23, cps_080 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 24, cps_080 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 25, cps_080 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 26, cps_080 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 27, cps_080 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 28, cps_080 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 29, cps_080 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 30, cps_080 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 31, cps_080 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 32, cps_080 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 33, cps_080 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 34, cps_080 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 35, cps_080 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 36, cps_080 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 37, cps_080 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 38, cps_080 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 39, cps_080 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 40, cps_080 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 41, cps_080 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 42, cps_080 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 43, cps_080 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 44, cps_080 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 45, cps_080 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 46, cps_080 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 47, cps_080 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 48, cps_080 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_080 + 49, cps_080 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_080);
uint32_t cps_081[] = {
0x108b, 0x108c, 0x108d, 0x108e, 0x108f, 0x1090, 0x1091, 0x1092, 0x1093, 0x1094, 0x1095, 0x1096, 0x1097, 0x1098, 0x1099, 0x109a, 0x109b, 0x109c, 0x109d, 0x109e, 0x109f, 0x10a0, 0x10a1, 0x10a2, 0x10a3, 0x10a4, 0x10a5, 0x10a6, 0x10a7, 0x10a8, 0x10a9, 0x10aa, 0x10ab, 0x10ac, 0x10ad, 0x10ae, 0x10af, 0x10b0, 0x10b1, 0x10b2, 0x10b3, 0x10b4, 0x10b5, 0x10b6, 0x10b7, 0x10b8, 0x10b9, 0x10ba, 0x10bb, 0x10bc
};
void BM_collation_element_lookup_081(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 0, cps_081 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 1, cps_081 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 2, cps_081 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 3, cps_081 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 4, cps_081 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 5, cps_081 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 6, cps_081 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 7, cps_081 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 8, cps_081 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 9, cps_081 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 10, cps_081 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 11, cps_081 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 12, cps_081 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 13, cps_081 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 14, cps_081 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 15, cps_081 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 16, cps_081 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 17, cps_081 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 18, cps_081 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 19, cps_081 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 20, cps_081 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 21, cps_081 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 22, cps_081 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 23, cps_081 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 24, cps_081 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 25, cps_081 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 26, cps_081 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 27, cps_081 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 28, cps_081 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 29, cps_081 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 30, cps_081 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 31, cps_081 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 32, cps_081 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 33, cps_081 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 34, cps_081 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 35, cps_081 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 36, cps_081 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 37, cps_081 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 38, cps_081 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 39, cps_081 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 40, cps_081 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 41, cps_081 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 42, cps_081 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 43, cps_081 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 44, cps_081 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 45, cps_081 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 46, cps_081 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 47, cps_081 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 48, cps_081 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_081 + 49, cps_081 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_081);
uint32_t cps_082[] = {
0x10bd, 0x10be, 0x10bf, 0x10c0, 0x10c1, 0x10c2, 0x10c3, 0x10c4, 0x10c5, 0x10c7, 0x10cd, 0x10d0, 0x10d1, 0x10d2, 0x10d3, 0x10d4, 0x10d5, 0x10d6, 0x10d7, 0x10d8, 0x10d9, 0x10da, 0x10db, 0x10dc, 0x10dd, 0x10de, 0x10df, 0x10e0, 0x10e1, 0x10e2, 0x10e3, 0x10e4, 0x10e5, 0x10e6, 0x10e7, 0x10e8, 0x10e9, 0x10ea, 0x10eb, 0x10ec, 0x10ed, 0x10ee, 0x10ef, 0x10f0, 0x10f1, 0x10f2, 0x10f3, 0x10f4, 0x10f5, 0x10f6
};
void BM_collation_element_lookup_082(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 0, cps_082 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 1, cps_082 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 2, cps_082 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 3, cps_082 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 4, cps_082 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 5, cps_082 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 6, cps_082 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 7, cps_082 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 8, cps_082 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 9, cps_082 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 10, cps_082 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 11, cps_082 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 12, cps_082 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 13, cps_082 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 14, cps_082 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 15, cps_082 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 16, cps_082 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 17, cps_082 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 18, cps_082 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 19, cps_082 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 20, cps_082 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 21, cps_082 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 22, cps_082 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 23, cps_082 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 24, cps_082 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 25, cps_082 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 26, cps_082 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 27, cps_082 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 28, cps_082 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 29, cps_082 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 30, cps_082 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 31, cps_082 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 32, cps_082 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 33, cps_082 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 34, cps_082 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 35, cps_082 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 36, cps_082 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 37, cps_082 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 38, cps_082 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 39, cps_082 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 40, cps_082 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 41, cps_082 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 42, cps_082 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 43, cps_082 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 44, cps_082 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 45, cps_082 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 46, cps_082 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 47, cps_082 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 48, cps_082 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_082 + 49, cps_082 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_082);
uint32_t cps_083[] = {
0x10f7, 0x10f8, 0x10f9, 0x10fa, 0x10fb, 0x10fc, 0x10fd, 0x10fe, 0x10ff, 0x1100, 0x1101, 0x1102, 0x1103, 0x1104, 0x1105, 0x1106, 0x1107, 0x1108, 0x1109, 0x110a, 0x110b, 0x110c, 0x110d, 0x110e, 0x110f, 0x1110, 0x1111, 0x1112, 0x1113, 0x1114, 0x1115, 0x1116, 0x1117, 0x1118, 0x1119, 0x111a, 0x111b, 0x111c, 0x111d, 0x111e, 0x111f, 0x1120, 0x1121, 0x1122, 0x1123, 0x1124, 0x1125, 0x1126, 0x1127, 0x1128
};
void BM_collation_element_lookup_083(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 0, cps_083 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 1, cps_083 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 2, cps_083 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 3, cps_083 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 4, cps_083 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 5, cps_083 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 6, cps_083 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 7, cps_083 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 8, cps_083 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 9, cps_083 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 10, cps_083 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 11, cps_083 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 12, cps_083 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 13, cps_083 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 14, cps_083 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 15, cps_083 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 16, cps_083 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 17, cps_083 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 18, cps_083 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 19, cps_083 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 20, cps_083 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 21, cps_083 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 22, cps_083 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 23, cps_083 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 24, cps_083 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 25, cps_083 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 26, cps_083 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 27, cps_083 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 28, cps_083 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 29, cps_083 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 30, cps_083 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 31, cps_083 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 32, cps_083 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 33, cps_083 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 34, cps_083 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 35, cps_083 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 36, cps_083 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 37, cps_083 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 38, cps_083 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 39, cps_083 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 40, cps_083 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 41, cps_083 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 42, cps_083 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 43, cps_083 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 44, cps_083 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 45, cps_083 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 46, cps_083 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 47, cps_083 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 48, cps_083 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_083 + 49, cps_083 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_083);
uint32_t cps_084[] = {
0x1129, 0x112a, 0x112b, 0x112c, 0x112d, 0x112e, 0x112f, 0x1130, 0x1131, 0x1132, 0x1133, 0x1134, 0x1135, 0x1136, 0x1137, 0x1138, 0x1139, 0x113a, 0x113b, 0x113c, 0x113d, 0x113e, 0x113f, 0x1140, 0x1141, 0x1142, 0x1143, 0x1144, 0x1145, 0x1146, 0x1147, 0x1148, 0x1149, 0x114a, 0x114b, 0x114c, 0x114d, 0x114e, 0x114f, 0x1150, 0x1151, 0x1152, 0x1153, 0x1154, 0x1155, 0x1156, 0x1157, 0x1158, 0x1159, 0x115a
};
void BM_collation_element_lookup_084(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 0, cps_084 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 1, cps_084 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 2, cps_084 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 3, cps_084 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 4, cps_084 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 5, cps_084 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 6, cps_084 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 7, cps_084 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 8, cps_084 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 9, cps_084 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 10, cps_084 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 11, cps_084 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 12, cps_084 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 13, cps_084 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 14, cps_084 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 15, cps_084 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 16, cps_084 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 17, cps_084 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 18, cps_084 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 19, cps_084 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 20, cps_084 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 21, cps_084 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 22, cps_084 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 23, cps_084 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 24, cps_084 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 25, cps_084 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 26, cps_084 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 27, cps_084 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 28, cps_084 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 29, cps_084 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 30, cps_084 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 31, cps_084 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 32, cps_084 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 33, cps_084 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 34, cps_084 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 35, cps_084 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 36, cps_084 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 37, cps_084 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 38, cps_084 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 39, cps_084 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 40, cps_084 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 41, cps_084 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 42, cps_084 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 43, cps_084 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 44, cps_084 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 45, cps_084 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 46, cps_084 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 47, cps_084 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 48, cps_084 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_084 + 49, cps_084 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_084);
uint32_t cps_085[] = {
0x115b, 0x115c, 0x115d, 0x115e, 0x115f, 0x1160, 0x1161, 0x1162, 0x1163, 0x1164, 0x1165, 0x1166, 0x1167, 0x1168, 0x1169, 0x116a, 0x116b, 0x116c, 0x116d, 0x116e, 0x116f, 0x1170, 0x1171, 0x1172, 0x1173, 0x1174, 0x1175, 0x1176, 0x1177, 0x1178, 0x1179, 0x117a, 0x117b, 0x117c, 0x117d, 0x117e, 0x117f, 0x1180, 0x1181, 0x1182, 0x1183, 0x1184, 0x1185, 0x1186, 0x1187, 0x1188, 0x1189, 0x118a, 0x118b, 0x118c
};
void BM_collation_element_lookup_085(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 0, cps_085 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 1, cps_085 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 2, cps_085 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 3, cps_085 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 4, cps_085 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 5, cps_085 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 6, cps_085 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 7, cps_085 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 8, cps_085 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 9, cps_085 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 10, cps_085 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 11, cps_085 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 12, cps_085 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 13, cps_085 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 14, cps_085 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 15, cps_085 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 16, cps_085 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 17, cps_085 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 18, cps_085 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 19, cps_085 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 20, cps_085 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 21, cps_085 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 22, cps_085 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 23, cps_085 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 24, cps_085 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 25, cps_085 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 26, cps_085 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 27, cps_085 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 28, cps_085 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 29, cps_085 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 30, cps_085 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 31, cps_085 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 32, cps_085 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 33, cps_085 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 34, cps_085 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 35, cps_085 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 36, cps_085 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 37, cps_085 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 38, cps_085 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 39, cps_085 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 40, cps_085 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 41, cps_085 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 42, cps_085 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 43, cps_085 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 44, cps_085 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 45, cps_085 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 46, cps_085 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 47, cps_085 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 48, cps_085 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_085 + 49, cps_085 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_085);
uint32_t cps_086[] = {
0x118d, 0x118e, 0x118f, 0x1190, 0x1191, 0x1192, 0x1193, 0x1194, 0x1195, 0x1196, 0x1197, 0x1198, 0x1199, 0x119a, 0x119b, 0x119c, 0x119d, 0x119e, 0x119f, 0x11a0, 0x11a1, 0x11a2, 0x11a3, 0x11a4, 0x11a5, 0x11a6, 0x11a7, 0x11a8, 0x11a9, 0x11aa, 0x11ab, 0x11ac, 0x11ad, 0x11ae, 0x11af, 0x11b0, 0x11b1, 0x11b2, 0x11b3, 0x11b4, 0x11b5, 0x11b6, 0x11b7, 0x11b8, 0x11b9, 0x11ba, 0x11bb, 0x11bc, 0x11bd, 0x11be
};
void BM_collation_element_lookup_086(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 0, cps_086 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 1, cps_086 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 2, cps_086 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 3, cps_086 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 4, cps_086 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 5, cps_086 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 6, cps_086 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 7, cps_086 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 8, cps_086 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 9, cps_086 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 10, cps_086 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 11, cps_086 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 12, cps_086 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 13, cps_086 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 14, cps_086 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 15, cps_086 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 16, cps_086 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 17, cps_086 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 18, cps_086 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 19, cps_086 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 20, cps_086 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 21, cps_086 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 22, cps_086 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 23, cps_086 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 24, cps_086 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 25, cps_086 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 26, cps_086 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 27, cps_086 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 28, cps_086 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 29, cps_086 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 30, cps_086 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 31, cps_086 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 32, cps_086 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 33, cps_086 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 34, cps_086 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 35, cps_086 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 36, cps_086 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 37, cps_086 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 38, cps_086 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 39, cps_086 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 40, cps_086 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 41, cps_086 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 42, cps_086 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 43, cps_086 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 44, cps_086 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 45, cps_086 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 46, cps_086 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 47, cps_086 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 48, cps_086 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_086 + 49, cps_086 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_086);
uint32_t cps_087[] = {
0x11bf, 0x11c0, 0x11c1, 0x11c2, 0x11c3, 0x11c4, 0x11c5, 0x11c6, 0x11c7, 0x11c8, 0x11c9, 0x11ca, 0x11cb, 0x11cc, 0x11cd, 0x11ce, 0x11cf, 0x11d0, 0x11d1, 0x11d2, 0x11d3, 0x11d4, 0x11d5, 0x11d6, 0x11d7, 0x11d8, 0x11d9, 0x11da, 0x11db, 0x11dc, 0x11dd, 0x11de, 0x11df, 0x11e0, 0x11e1, 0x11e2, 0x11e3, 0x11e4, 0x11e5, 0x11e6, 0x11e7, 0x11e8, 0x11e9, 0x11ea, 0x11eb, 0x11ec, 0x11ed, 0x11ee, 0x11ef, 0x11f0
};
void BM_collation_element_lookup_087(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 0, cps_087 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 1, cps_087 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 2, cps_087 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 3, cps_087 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 4, cps_087 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 5, cps_087 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 6, cps_087 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 7, cps_087 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 8, cps_087 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 9, cps_087 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 10, cps_087 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 11, cps_087 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 12, cps_087 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 13, cps_087 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 14, cps_087 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 15, cps_087 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 16, cps_087 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 17, cps_087 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 18, cps_087 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 19, cps_087 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 20, cps_087 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 21, cps_087 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 22, cps_087 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 23, cps_087 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 24, cps_087 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 25, cps_087 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 26, cps_087 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 27, cps_087 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 28, cps_087 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 29, cps_087 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 30, cps_087 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 31, cps_087 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 32, cps_087 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 33, cps_087 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 34, cps_087 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 35, cps_087 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 36, cps_087 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 37, cps_087 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 38, cps_087 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 39, cps_087 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 40, cps_087 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 41, cps_087 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 42, cps_087 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 43, cps_087 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 44, cps_087 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 45, cps_087 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 46, cps_087 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 47, cps_087 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 48, cps_087 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_087 + 49, cps_087 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_087);
uint32_t cps_088[] = {
0x11f1, 0x11f2, 0x11f3, 0x11f4, 0x11f5, 0x11f6, 0x11f7, 0x11f8, 0x11f9, 0x11fa, 0x11fb, 0x11fc, 0x11fd, 0x11fe, 0x11ff, 0x1200, 0x1201, 0x1202, 0x1203, 0x1204, 0x1205, 0x1206, 0x1207, 0x1208, 0x1209, 0x120a, 0x120b, 0x120c, 0x120d, 0x120e, 0x120f, 0x1210, 0x1211, 0x1212, 0x1213, 0x1214, 0x1215, 0x1216, 0x1217, 0x1218, 0x1219, 0x121a, 0x121b, 0x121c, 0x121d, 0x121e, 0x121f, 0x1220, 0x1221, 0x1222
};
void BM_collation_element_lookup_088(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 0, cps_088 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 1, cps_088 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 2, cps_088 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 3, cps_088 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 4, cps_088 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 5, cps_088 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 6, cps_088 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 7, cps_088 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 8, cps_088 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 9, cps_088 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 10, cps_088 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 11, cps_088 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 12, cps_088 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 13, cps_088 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 14, cps_088 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 15, cps_088 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 16, cps_088 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 17, cps_088 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 18, cps_088 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 19, cps_088 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 20, cps_088 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 21, cps_088 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 22, cps_088 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 23, cps_088 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 24, cps_088 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 25, cps_088 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 26, cps_088 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 27, cps_088 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 28, cps_088 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 29, cps_088 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 30, cps_088 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 31, cps_088 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 32, cps_088 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 33, cps_088 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 34, cps_088 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 35, cps_088 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 36, cps_088 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 37, cps_088 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 38, cps_088 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 39, cps_088 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 40, cps_088 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 41, cps_088 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 42, cps_088 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 43, cps_088 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 44, cps_088 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 45, cps_088 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 46, cps_088 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 47, cps_088 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 48, cps_088 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_088 + 49, cps_088 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_088);
uint32_t cps_089[] = {
0x1223, 0x1224, 0x1225, 0x1226, 0x1227, 0x1228, 0x1229, 0x122a, 0x122b, 0x122c, 0x122d, 0x122e, 0x122f, 0x1230, 0x1231, 0x1232, 0x1233, 0x1234, 0x1235, 0x1236, 0x1237, 0x1238, 0x1239, 0x123a, 0x123b, 0x123c, 0x123d, 0x123e, 0x123f, 0x1240, 0x1241, 0x1242, 0x1243, 0x1244, 0x1245, 0x1246, 0x1247, 0x1248, 0x124a, 0x124b, 0x124c, 0x124d, 0x1250, 0x1251, 0x1252, 0x1253, 0x1254, 0x1255, 0x1256, 0x1258
};
void BM_collation_element_lookup_089(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 0, cps_089 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 1, cps_089 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 2, cps_089 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 3, cps_089 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 4, cps_089 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 5, cps_089 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 6, cps_089 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 7, cps_089 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 8, cps_089 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 9, cps_089 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 10, cps_089 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 11, cps_089 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 12, cps_089 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 13, cps_089 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 14, cps_089 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 15, cps_089 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 16, cps_089 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 17, cps_089 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 18, cps_089 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 19, cps_089 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 20, cps_089 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 21, cps_089 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 22, cps_089 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 23, cps_089 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 24, cps_089 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 25, cps_089 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 26, cps_089 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 27, cps_089 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 28, cps_089 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 29, cps_089 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 30, cps_089 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 31, cps_089 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 32, cps_089 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 33, cps_089 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 34, cps_089 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 35, cps_089 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 36, cps_089 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 37, cps_089 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 38, cps_089 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 39, cps_089 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 40, cps_089 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 41, cps_089 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 42, cps_089 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 43, cps_089 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 44, cps_089 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 45, cps_089 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 46, cps_089 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 47, cps_089 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 48, cps_089 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_089 + 49, cps_089 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_089);
uint32_t cps_090[] = {
0x125a, 0x125b, 0x125c, 0x125d, 0x1260, 0x1261, 0x1262, 0x1263, 0x1264, 0x1265, 0x1266, 0x1267, 0x1268, 0x1269, 0x126a, 0x126b, 0x126c, 0x126d, 0x126e, 0x126f, 0x1270, 0x1271, 0x1272, 0x1273, 0x1274, 0x1275, 0x1276, 0x1277, 0x1278, 0x1279, 0x127a, 0x127b, 0x127c, 0x127d, 0x127e, 0x127f, 0x1280, 0x1281, 0x1282, 0x1283, 0x1284, 0x1285, 0x1286, 0x1287, 0x1288, 0x128a, 0x128b, 0x128c, 0x128d, 0x1290
};
void BM_collation_element_lookup_090(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 0, cps_090 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 1, cps_090 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 2, cps_090 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 3, cps_090 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 4, cps_090 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 5, cps_090 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 6, cps_090 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 7, cps_090 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 8, cps_090 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 9, cps_090 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 10, cps_090 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 11, cps_090 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 12, cps_090 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 13, cps_090 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 14, cps_090 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 15, cps_090 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 16, cps_090 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 17, cps_090 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 18, cps_090 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 19, cps_090 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 20, cps_090 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 21, cps_090 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 22, cps_090 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 23, cps_090 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 24, cps_090 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 25, cps_090 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 26, cps_090 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 27, cps_090 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 28, cps_090 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 29, cps_090 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 30, cps_090 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 31, cps_090 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 32, cps_090 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 33, cps_090 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 34, cps_090 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 35, cps_090 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 36, cps_090 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 37, cps_090 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 38, cps_090 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 39, cps_090 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 40, cps_090 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 41, cps_090 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 42, cps_090 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 43, cps_090 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 44, cps_090 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 45, cps_090 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 46, cps_090 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 47, cps_090 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 48, cps_090 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_090 + 49, cps_090 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_090);
uint32_t cps_091[] = {
0x1291, 0x1292, 0x1293, 0x1294, 0x1295, 0x1296, 0x1297, 0x1298, 0x1299, 0x129a, 0x129b, 0x129c, 0x129d, 0x129e, 0x129f, 0x12a0, 0x12a1, 0x12a2, 0x12a3, 0x12a4, 0x12a5, 0x12a6, 0x12a7, 0x12a8, 0x12a9, 0x12aa, 0x12ab, 0x12ac, 0x12ad, 0x12ae, 0x12af, 0x12b0, 0x12b2, 0x12b3, 0x12b4, 0x12b5, 0x12b8, 0x12b9, 0x12ba, 0x12bb, 0x12bc, 0x12bd, 0x12be, 0x12c0, 0x12c2, 0x12c3, 0x12c4, 0x12c5, 0x12c8, 0x12c9
};
void BM_collation_element_lookup_091(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 0, cps_091 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 1, cps_091 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 2, cps_091 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 3, cps_091 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 4, cps_091 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 5, cps_091 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 6, cps_091 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 7, cps_091 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 8, cps_091 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 9, cps_091 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 10, cps_091 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 11, cps_091 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 12, cps_091 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 13, cps_091 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 14, cps_091 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 15, cps_091 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 16, cps_091 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 17, cps_091 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 18, cps_091 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 19, cps_091 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 20, cps_091 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 21, cps_091 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 22, cps_091 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 23, cps_091 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 24, cps_091 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 25, cps_091 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 26, cps_091 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 27, cps_091 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 28, cps_091 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 29, cps_091 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 30, cps_091 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 31, cps_091 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 32, cps_091 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 33, cps_091 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 34, cps_091 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 35, cps_091 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 36, cps_091 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 37, cps_091 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 38, cps_091 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 39, cps_091 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 40, cps_091 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 41, cps_091 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 42, cps_091 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 43, cps_091 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 44, cps_091 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 45, cps_091 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 46, cps_091 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 47, cps_091 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 48, cps_091 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_091 + 49, cps_091 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_091);
uint32_t cps_092[] = {
0x12ca, 0x12cb, 0x12cc, 0x12cd, 0x12ce, 0x12cf, 0x12d0, 0x12d1, 0x12d2, 0x12d3, 0x12d4, 0x12d5, 0x12d6, 0x12d8, 0x12d9, 0x12da, 0x12db, 0x12dc, 0x12dd, 0x12de, 0x12df, 0x12e0, 0x12e1, 0x12e2, 0x12e3, 0x12e4, 0x12e5, 0x12e6, 0x12e7, 0x12e8, 0x12e9, 0x12ea, 0x12eb, 0x12ec, 0x12ed, 0x12ee, 0x12ef, 0x12f0, 0x12f1, 0x12f2, 0x12f3, 0x12f4, 0x12f5, 0x12f6, 0x12f7, 0x12f8, 0x12f9, 0x12fa, 0x12fb, 0x12fc
};
void BM_collation_element_lookup_092(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 0, cps_092 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 1, cps_092 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 2, cps_092 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 3, cps_092 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 4, cps_092 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 5, cps_092 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 6, cps_092 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 7, cps_092 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 8, cps_092 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 9, cps_092 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 10, cps_092 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 11, cps_092 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 12, cps_092 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 13, cps_092 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 14, cps_092 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 15, cps_092 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 16, cps_092 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 17, cps_092 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 18, cps_092 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 19, cps_092 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 20, cps_092 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 21, cps_092 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 22, cps_092 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 23, cps_092 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 24, cps_092 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 25, cps_092 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 26, cps_092 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 27, cps_092 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 28, cps_092 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 29, cps_092 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 30, cps_092 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 31, cps_092 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 32, cps_092 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 33, cps_092 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 34, cps_092 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 35, cps_092 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 36, cps_092 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 37, cps_092 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 38, cps_092 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 39, cps_092 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 40, cps_092 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 41, cps_092 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 42, cps_092 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 43, cps_092 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 44, cps_092 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 45, cps_092 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 46, cps_092 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 47, cps_092 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 48, cps_092 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_092 + 49, cps_092 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_092);
uint32_t cps_093[] = {
0x12fd, 0x12fe, 0x12ff, 0x1300, 0x1301, 0x1302, 0x1303, 0x1304, 0x1305, 0x1306, 0x1307, 0x1308, 0x1309, 0x130a, 0x130b, 0x130c, 0x130d, 0x130e, 0x130f, 0x1310, 0x1312, 0x1313, 0x1314, 0x1315, 0x1318, 0x1319, 0x131a, 0x131b, 0x131c, 0x131d, 0x131e, 0x131f, 0x1320, 0x1321, 0x1322, 0x1323, 0x1324, 0x1325, 0x1326, 0x1327, 0x1328, 0x1329, 0x132a, 0x132b, 0x132c, 0x132d, 0x132e, 0x132f, 0x1330, 0x1331
};
void BM_collation_element_lookup_093(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 0, cps_093 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 1, cps_093 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 2, cps_093 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 3, cps_093 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 4, cps_093 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 5, cps_093 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 6, cps_093 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 7, cps_093 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 8, cps_093 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 9, cps_093 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 10, cps_093 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 11, cps_093 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 12, cps_093 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 13, cps_093 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 14, cps_093 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 15, cps_093 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 16, cps_093 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 17, cps_093 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 18, cps_093 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 19, cps_093 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 20, cps_093 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 21, cps_093 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 22, cps_093 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 23, cps_093 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 24, cps_093 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 25, cps_093 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 26, cps_093 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 27, cps_093 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 28, cps_093 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 29, cps_093 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 30, cps_093 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 31, cps_093 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 32, cps_093 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 33, cps_093 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 34, cps_093 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 35, cps_093 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 36, cps_093 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 37, cps_093 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 38, cps_093 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 39, cps_093 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 40, cps_093 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 41, cps_093 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 42, cps_093 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 43, cps_093 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 44, cps_093 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 45, cps_093 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 46, cps_093 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 47, cps_093 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 48, cps_093 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_093 + 49, cps_093 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_093);
uint32_t cps_094[] = {
0x1332, 0x1333, 0x1334, 0x1335, 0x1336, 0x1337, 0x1338, 0x1339, 0x133a, 0x133b, 0x133c, 0x133d, 0x133e, 0x133f, 0x1340, 0x1341, 0x1342, 0x1343, 0x1344, 0x1345, 0x1346, 0x1347, 0x1348, 0x1349, 0x134a, 0x134b, 0x134c, 0x134d, 0x134e, 0x134f, 0x1350, 0x1351, 0x1352, 0x1353, 0x1354, 0x1355, 0x1356, 0x1357, 0x1358, 0x1359, 0x135a, 0x135d, 0x135e, 0x135f, 0x1360, 0x1361, 0x1362, 0x1363, 0x1364, 0x1365
};
void BM_collation_element_lookup_094(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 0, cps_094 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 1, cps_094 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 2, cps_094 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 3, cps_094 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 4, cps_094 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 5, cps_094 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 6, cps_094 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 7, cps_094 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 8, cps_094 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 9, cps_094 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 10, cps_094 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 11, cps_094 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 12, cps_094 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 13, cps_094 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 14, cps_094 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 15, cps_094 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 16, cps_094 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 17, cps_094 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 18, cps_094 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 19, cps_094 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 20, cps_094 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 21, cps_094 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 22, cps_094 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 23, cps_094 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 24, cps_094 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 25, cps_094 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 26, cps_094 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 27, cps_094 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 28, cps_094 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 29, cps_094 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 30, cps_094 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 31, cps_094 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 32, cps_094 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 33, cps_094 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 34, cps_094 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 35, cps_094 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 36, cps_094 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 37, cps_094 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 38, cps_094 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 39, cps_094 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 40, cps_094 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 41, cps_094 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 42, cps_094 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 43, cps_094 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 44, cps_094 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 45, cps_094 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 46, cps_094 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 47, cps_094 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 48, cps_094 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_094 + 49, cps_094 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_094);
uint32_t cps_095[] = {
0x1366, 0x1367, 0x1368, 0x1369, 0x136a, 0x136b, 0x136c, 0x136d, 0x136e, 0x136f, 0x1370, 0x1371, 0x1372, 0x1373, 0x1374, 0x1375, 0x1376, 0x1377, 0x1378, 0x1379, 0x137a, 0x137b, 0x137c, 0x1380, 0x1381, 0x1382, 0x1383, 0x1384, 0x1385, 0x1386, 0x1387, 0x1388, 0x1389, 0x138a, 0x138b, 0x138c, 0x138d, 0x138e, 0x138f, 0x1390, 0x1391, 0x1392, 0x1393, 0x1394, 0x1395, 0x1396, 0x1397, 0x1398, 0x1399, 0x13a0
};
void BM_collation_element_lookup_095(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 0, cps_095 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 1, cps_095 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 2, cps_095 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 3, cps_095 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 4, cps_095 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 5, cps_095 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 6, cps_095 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 7, cps_095 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 8, cps_095 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 9, cps_095 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 10, cps_095 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 11, cps_095 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 12, cps_095 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 13, cps_095 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 14, cps_095 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 15, cps_095 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 16, cps_095 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 17, cps_095 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 18, cps_095 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 19, cps_095 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 20, cps_095 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 21, cps_095 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 22, cps_095 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 23, cps_095 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 24, cps_095 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 25, cps_095 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 26, cps_095 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 27, cps_095 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 28, cps_095 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 29, cps_095 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 30, cps_095 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 31, cps_095 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 32, cps_095 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 33, cps_095 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 34, cps_095 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 35, cps_095 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 36, cps_095 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 37, cps_095 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 38, cps_095 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 39, cps_095 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 40, cps_095 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 41, cps_095 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 42, cps_095 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 43, cps_095 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 44, cps_095 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 45, cps_095 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 46, cps_095 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 47, cps_095 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 48, cps_095 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_095 + 49, cps_095 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_095);
uint32_t cps_096[] = {
0x13a1, 0x13a2, 0x13a3, 0x13a4, 0x13a5, 0x13a6, 0x13a7, 0x13a8, 0x13a9, 0x13aa, 0x13ab, 0x13ac, 0x13ad, 0x13ae, 0x13af, 0x13b0, 0x13b1, 0x13b2, 0x13b3, 0x13b4, 0x13b5, 0x13b6, 0x13b7, 0x13b8, 0x13b9, 0x13ba, 0x13bb, 0x13bc, 0x13bd, 0x13be, 0x13bf, 0x13c0, 0x13c1, 0x13c2, 0x13c3, 0x13c4, 0x13c5, 0x13c6, 0x13c7, 0x13c8, 0x13c9, 0x13ca, 0x13cb, 0x13cc, 0x13cd, 0x13ce, 0x13cf, 0x13d0, 0x13d1, 0x13d2
};
void BM_collation_element_lookup_096(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 0, cps_096 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 1, cps_096 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 2, cps_096 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 3, cps_096 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 4, cps_096 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 5, cps_096 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 6, cps_096 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 7, cps_096 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 8, cps_096 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 9, cps_096 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 10, cps_096 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 11, cps_096 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 12, cps_096 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 13, cps_096 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 14, cps_096 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 15, cps_096 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 16, cps_096 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 17, cps_096 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 18, cps_096 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 19, cps_096 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 20, cps_096 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 21, cps_096 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 22, cps_096 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 23, cps_096 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 24, cps_096 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 25, cps_096 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 26, cps_096 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 27, cps_096 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 28, cps_096 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 29, cps_096 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 30, cps_096 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 31, cps_096 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 32, cps_096 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 33, cps_096 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 34, cps_096 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 35, cps_096 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 36, cps_096 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 37, cps_096 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 38, cps_096 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 39, cps_096 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 40, cps_096 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 41, cps_096 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 42, cps_096 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 43, cps_096 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 44, cps_096 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 45, cps_096 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 46, cps_096 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 47, cps_096 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 48, cps_096 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_096 + 49, cps_096 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_096);
uint32_t cps_097[] = {
0x13d3, 0x13d4, 0x13d5, 0x13d6, 0x13d7, 0x13d8, 0x13d9, 0x13da, 0x13db, 0x13dc, 0x13dd, 0x13de, 0x13df, 0x13e0, 0x13e1, 0x13e2, 0x13e3, 0x13e4, 0x13e5, 0x13e6, 0x13e7, 0x13e8, 0x13e9, 0x13ea, 0x13eb, 0x13ec, 0x13ed, 0x13ee, 0x13ef, 0x13f0, 0x13f1, 0x13f2, 0x13f3, 0x13f4, 0x13f5, 0x13f8, 0x13f9, 0x13fa, 0x13fb, 0x13fc, 0x13fd, 0x1400, 0x1401, 0x1402, 0x1403, 0x1404, 0x1405, 0x1406, 0x1407, 0x1408
};
void BM_collation_element_lookup_097(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 0, cps_097 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 1, cps_097 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 2, cps_097 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 3, cps_097 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 4, cps_097 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 5, cps_097 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 6, cps_097 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 7, cps_097 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 8, cps_097 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 9, cps_097 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 10, cps_097 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 11, cps_097 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 12, cps_097 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 13, cps_097 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 14, cps_097 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 15, cps_097 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 16, cps_097 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 17, cps_097 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 18, cps_097 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 19, cps_097 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 20, cps_097 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 21, cps_097 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 22, cps_097 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 23, cps_097 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 24, cps_097 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 25, cps_097 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 26, cps_097 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 27, cps_097 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 28, cps_097 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 29, cps_097 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 30, cps_097 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 31, cps_097 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 32, cps_097 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 33, cps_097 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 34, cps_097 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 35, cps_097 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 36, cps_097 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 37, cps_097 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 38, cps_097 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 39, cps_097 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 40, cps_097 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 41, cps_097 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 42, cps_097 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 43, cps_097 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 44, cps_097 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 45, cps_097 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 46, cps_097 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 47, cps_097 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 48, cps_097 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_097 + 49, cps_097 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_097);
uint32_t cps_098[] = {
0x1409, 0x140a, 0x140b, 0x140c, 0x140d, 0x140e, 0x140f, 0x1410, 0x1411, 0x1412, 0x1413, 0x1414, 0x1415, 0x1416, 0x1417, 0x1418, 0x1419, 0x141a, 0x141b, 0x141c, 0x141d, 0x141e, 0x141f, 0x1420, 0x1421, 0x1422, 0x1423, 0x1424, 0x1425, 0x1426, 0x1427, 0x1428, 0x1429, 0x142a, 0x142b, 0x142c, 0x142d, 0x142e, 0x142f, 0x1430, 0x1431, 0x1432, 0x1433, 0x1434, 0x1435, 0x1436, 0x1437, 0x1438, 0x1439, 0x143a
};
void BM_collation_element_lookup_098(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 0, cps_098 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 1, cps_098 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 2, cps_098 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 3, cps_098 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 4, cps_098 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 5, cps_098 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 6, cps_098 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 7, cps_098 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 8, cps_098 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 9, cps_098 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 10, cps_098 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 11, cps_098 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 12, cps_098 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 13, cps_098 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 14, cps_098 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 15, cps_098 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 16, cps_098 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 17, cps_098 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 18, cps_098 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 19, cps_098 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 20, cps_098 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 21, cps_098 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 22, cps_098 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 23, cps_098 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 24, cps_098 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 25, cps_098 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 26, cps_098 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 27, cps_098 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 28, cps_098 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 29, cps_098 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 30, cps_098 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 31, cps_098 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 32, cps_098 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 33, cps_098 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 34, cps_098 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 35, cps_098 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 36, cps_098 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 37, cps_098 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 38, cps_098 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 39, cps_098 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 40, cps_098 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 41, cps_098 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 42, cps_098 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 43, cps_098 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 44, cps_098 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 45, cps_098 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 46, cps_098 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 47, cps_098 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 48, cps_098 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_098 + 49, cps_098 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_098);
uint32_t cps_099[] = {
0x143b, 0x143c, 0x143d, 0x143e, 0x143f, 0x1440, 0x1441, 0x1442, 0x1443, 0x1444, 0x1445, 0x1446, 0x1447, 0x1448, 0x1449, 0x144a, 0x144b, 0x144c, 0x144d, 0x144e, 0x144f, 0x1450, 0x1451, 0x1452, 0x1453, 0x1454, 0x1455, 0x1456, 0x1457, 0x1458, 0x1459, 0x145a, 0x145b, 0x145c, 0x145d, 0x145e, 0x145f, 0x1460, 0x1461, 0x1462, 0x1463, 0x1464, 0x1465, 0x1466, 0x1467, 0x1468, 0x1469, 0x146a, 0x146b, 0x146c
};
void BM_collation_element_lookup_099(benchmark::State & state)
{
while (state.KeepRunning()) {
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 0, cps_099 + 1));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 1, cps_099 + 2));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 2, cps_099 + 3));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 3, cps_099 + 4));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 4, cps_099 + 5));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 5, cps_099 + 6));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 6, cps_099 + 7));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 7, cps_099 + 8));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 8, cps_099 + 9));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 9, cps_099 + 10));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 10, cps_099 + 11));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 11, cps_099 + 12));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 12, cps_099 + 13));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 13, cps_099 + 14));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 14, cps_099 + 15));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 15, cps_099 + 16));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 16, cps_099 + 17));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 17, cps_099 + 18));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 18, cps_099 + 19));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 19, cps_099 + 20));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 20, cps_099 + 21));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 21, cps_099 + 22));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 22, cps_099 + 23));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 23, cps_099 + 24));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 24, cps_099 + 25));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 25, cps_099 + 26));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 26, cps_099 + 27));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 27, cps_099 + 28));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 28, cps_099 + 29));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 29, cps_099 + 30));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 30, cps_099 + 31));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 31, cps_099 + 32));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 32, cps_099 + 33));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 33, cps_099 + 34));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 34, cps_099 + 35));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 35, cps_099 + 36));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 36, cps_099 + 37));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 37, cps_099 + 38));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 38, cps_099 + 39));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 39, cps_099 + 40));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 40, cps_099 + 41));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 41, cps_099 + 42));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 42, cps_099 + 43));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 43, cps_099 + 44));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 44, cps_099 + 45));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 45, cps_099 + 46));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 46, cps_099 + 47));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 47, cps_099 + 48));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 48, cps_099 + 49));
benchmark::DoNotOptimize(trie().longest_match(cps_099 + 49, cps_099 + 50));
}
}
BENCHMARK(BM_collation_element_lookup_099);
BENCHMARK_MAIN()
| 80.926005
| 691
| 0.655196
|
eightysquirrels
|
600afc24f9fd5020507343c361e01efafcfc9780
| 58,388
|
cpp
|
C++
|
test/unit/api/x_init_reset_close.cpp
|
wd13384/oneVPL-cpu
|
f46bc287cbd4f7438d96ac76e460ccbf561fd958
|
[
"MIT"
] | null | null | null |
test/unit/api/x_init_reset_close.cpp
|
wd13384/oneVPL-cpu
|
f46bc287cbd4f7438d96ac76e460ccbf561fd958
|
[
"MIT"
] | null | null | null |
test/unit/api/x_init_reset_close.cpp
|
wd13384/oneVPL-cpu
|
f46bc287cbd4f7438d96ac76e460ccbf561fd958
|
[
"MIT"
] | null | null | null |
/*############################################################################
# Copyright (C) 2020 Intel Corporation
#
# SPDX-License-Identifier: MIT
############################################################################*/
#include <gtest/gtest.h>
#include "vpl/mfxjpeg.h"
#include "vpl/mfxvideo.h"
/* Init overview
This function allocates memory and prepares structures for encode, decode, and VPP.
Parameters are validated to ensure they are supported.
MFX_ERR_NONE The function completed successfully. \n
MFX_ERR_INVALID_VIDEO_PARAM The function detected invalid video parameters.
These parameters may be out of the valid range, or the combination resulted in incompatibility.
Incompatibility not resolved. \n
MFX_WRN_INCOMPATIBLE_VIDEO_PARAM The function detected some video parameters were incompatible with others;
incompatibility resolved. \n
MFX_ERR_UNDEFINED_BEHAVIOR The function is called twice without a close;
*/
//EncodeInit
TEST(EncodeInit, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, ProtectedInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
mfxEncParams.Protected = MFX_CODINGOPTION_ON;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, HighAsyncInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
mfxEncParams.AsyncDepth = 256;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, InvalidChromaFormatInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV411;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, MissingIOPatternReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, InvalidIOPatternInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.IOPattern = 999;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, VideoIOPatternInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, OutIOPatternInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Init(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoENCODE_Init(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
TEST(EncodeInit, DoubleInitReturnsUndefinedBehavior) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_UNDEFINED_BEHAVIOR);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, EncodeParamsInReturnsInitializedHEVCContext) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxEncParams.mfx.TargetUsage = MFX_TARGETUSAGE_BALANCED;
mfxEncParams.mfx.TargetKbps = 4000;
mfxEncParams.mfx.InitialDelayInKB = 1000;
mfxEncParams.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
mfxEncParams.mfx.FrameInfo.CropX = 0;
mfxEncParams.mfx.FrameInfo.CropY = 0;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.NumSlice = 0;
mfxEncParams.mfx.FrameInfo.AspectRatioW = 4;
mfxEncParams.mfx.FrameInfo.AspectRatioH = 3;
mfxEncParams.mfx.CodecProfile = MFX_PROFILE_HEVC_MAIN;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
//GetVideoParam reads values from the encoder context
mfxVideoParam par;
sts = MFXVideoENCODE_GetVideoParam(session, &par);
ASSERT_EQ(sts, MFX_ERR_NONE);
ASSERT_EQ(128, par.mfx.FrameInfo.Width);
ASSERT_EQ(96, par.mfx.FrameInfo.Height);
ASSERT_EQ(MFX_RATECONTROL_VBR, par.mfx.RateControlMethod);
ASSERT_EQ(4000, par.mfx.TargetKbps);
ASSERT_EQ(1000, par.mfx.InitialDelayInKB);
ASSERT_EQ(0, par.mfx.NumSlice);
ASSERT_EQ(MFX_PROFILE_HEVC_MAIN, par.mfx.CodecProfile);
ASSERT_EQ(MFX_TARGETUSAGE_BALANCED, par.mfx.TargetUsage);
ASSERT_EQ(4, mfxEncParams.mfx.FrameInfo.AspectRatioW);
ASSERT_EQ(3, mfxEncParams.mfx.FrameInfo.AspectRatioH);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, EncodeParamsInReturnsInitializedAV1Context) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_AV1;
mfxEncParams.mfx.TargetUsage = MFX_TARGETUSAGE_BALANCED;
mfxEncParams.mfx.TargetKbps = 4000;
mfxEncParams.mfx.InitialDelayInKB = 1000;
mfxEncParams.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.PicStruct = MFX_PICSTRUCT_PROGRESSIVE;
mfxEncParams.mfx.FrameInfo.CropX = 0;
mfxEncParams.mfx.FrameInfo.CropY = 0;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.NumSlice = 0;
mfxEncParams.mfx.FrameInfo.AspectRatioW = 4;
mfxEncParams.mfx.FrameInfo.AspectRatioH = 3;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
//GetVideoParam reads values from the encoder context
mfxVideoParam par;
sts = MFXVideoENCODE_GetVideoParam(session, &par);
ASSERT_EQ(sts, MFX_ERR_NONE);
ASSERT_EQ(128, par.mfx.FrameInfo.Width);
ASSERT_EQ(96, par.mfx.FrameInfo.Height);
ASSERT_EQ(MFX_RATECONTROL_VBR, par.mfx.RateControlMethod);
ASSERT_EQ(4000, par.mfx.TargetKbps);
ASSERT_EQ(1000, par.mfx.InitialDelayInKB);
ASSERT_EQ(0, par.mfx.NumSlice);
ASSERT_EQ(MFX_TARGETUSAGE_BALANCED, par.mfx.TargetUsage);
ASSERT_EQ(4, mfxEncParams.mfx.FrameInfo.AspectRatioW);
ASSERT_EQ(3, mfxEncParams.mfx.FrameInfo.AspectRatioH);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, EncodeParamsInReturnsInitializedJPEGContext) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams;
memset(&mfxEncParams, 0, sizeof(mfxEncParams));
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
//GetVideoParam reads values from the encoder context
mfxVideoParam par;
sts = MFXVideoENCODE_GetVideoParam(session, &par);
ASSERT_EQ(sts, MFX_ERR_NONE);
ASSERT_EQ(128, par.mfx.FrameInfo.Width);
ASSERT_EQ(96, par.mfx.FrameInfo.Height);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, AV1CloseCrashes) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_AV1;
mfxEncParams.mfx.TargetUsage = MFX_TARGETUSAGE_BALANCED;
mfxEncParams.mfx.TargetKbps = 4000;
mfxEncParams.mfx.RateControlMethod = MFX_RATECONTROL_VBR;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropX = 0;
mfxEncParams.mfx.FrameInfo.CropY = 0;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
//GetVideoParam reads values from the encoder context
mfxVideoParam par;
sts = MFXVideoENCODE_GetVideoParam(session, &par);
ASSERT_EQ(sts, MFX_ERR_NONE);
ASSERT_EQ(128, par.mfx.FrameInfo.Width);
ASSERT_EQ(96, par.mfx.FrameInfo.Height);
ASSERT_EQ(MFX_RATECONTROL_VBR, par.mfx.RateControlMethod);
sts = MFXVideoENCODE_Close(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeInit, BadAV1GopSizeReturnsInvalidParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_AV1;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.GopPicSize = 121;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
//DecodeInit
TEST(DecodeInit, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, ProtectedInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
mfxDecParams.Protected = MFX_CODINGOPTION_ON;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, HighAsyncDepthInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
mfxDecParams.AsyncDepth = 256;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, MismatchedChromaFormatInReturnsErrInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV444;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, InvalidChromaFormatInReturnsErrInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV411;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, InValidFourCCInReturnsErrInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = 1;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, MissingIOPatternReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, InvalidIOPatternOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = 999;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, VideoIOPatternOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, InIOPatternOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoDECODE_Init(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeInit, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoDECODE_Init(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
TEST(DecodeInit, DoubleInitReturnsUndefinedBehavior) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_UNDEFINED_BEHAVIOR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
//VPPInit
TEST(VPPInit, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.Out.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, ProtectedInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.Out.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxVPPParams.Protected = MFX_CODINGOPTION_ON;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, HighAsyncDepthInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.Out.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxVPPParams.AsyncDepth = 256;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, InvalidChromaFormatInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV400;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.Out.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, InvalidIOPatternOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, VideoIOPatternOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, VideoIOPatternInOutReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, VideoIOPatternInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, MissingIOPatternReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoVPP_Init(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPInit, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoVPP_Init(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
TEST(VPPInit, DoubleInitReturnsUndefinedBehavior) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_UNDEFINED_BEHAVIOR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
/* Reset overview
This function stops the current operation and restores internal structures for a new operation,
possibly with new parameters.
For decode:
* It recovers the decoder from errors.
* It restarts decoding from a new position
The function resets the old sequence header (sequence parameter set in H.264, or sequence header in MPEG-2 and VC-1). The decoder will expect a new sequence header
before it decodes the next frame and will skip any bitstream before encountering the new sequence header.
MFX_ERR_NONE The function completed successfully. \n
MFX_ERR_INVALID_VIDEO_PARAM The function detected invalid video parameters. These parameters may be out of the valid range, or the combination of them
resulted in incompatibility. Incompatibility not resolved. \n
MFX_WRN_INCOMPATIBLE_VIDEO_PARAM The function detected some video parameters were incompatible with others; incompatibility resolved.
mfxStatus MFX_CDECL MFXVideoENCODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoDECODE_Reset(mfxSession session, mfxVideoParam *par);
mfxStatus MFX_CDECL MFXVideoVPP_Reset(mfxSession session, mfxVideoParam *par);
*/
//EncodeReset
TEST(EncodeReset, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Reset(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeReset, InvalidParamsInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_VIDEO_MEMORY;
sts = MFXVideoENCODE_Reset(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeReset, IncompatibleParamsInReturnsIncompatibleVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxEncParams.mfx.FrameInfo.Width = 640;
mfxEncParams.mfx.FrameInfo.Height = 480;
sts = MFXVideoENCODE_Reset(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_INCOMPATIBLE_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeReset, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Reset(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeReset, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoENCODE_Reset(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
//DecodeReset
TEST(DecodeReset, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoDECODE_Reset(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeReset, InvalidParamsInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
sts = MFXVideoDECODE_Reset(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
//profile/level incompatible with resolution
TEST(DecodeReset, IncompatibleParamsInReturnsIncompatibleVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxDecParams.mfx.FrameInfo.Width = 640;
mfxDecParams.mfx.FrameInfo.Height = 480;
sts = MFXVideoDECODE_Reset(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_INCOMPATIBLE_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeReset, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoDECODE_Reset(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeReset, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoDECODE_Reset(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
//VPPReset
TEST(VPPReset, ValidParamsInReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoVPP_Reset(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPReset, InvalidParamsInReturnsInvalidVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_P8;
sts = MFXVideoVPP_Reset(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INVALID_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPReset, IncompatibleParamsInReturnsIncompatibleVideoParam) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_VIDEO_MEMORY;
sts = MFXVideoVPP_Reset(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_INCOMPATIBLE_VIDEO_PARAM);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPReset, NullParamsInReturnsErrNull) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoVPP_Reset(session, nullptr);
ASSERT_EQ(sts, MFX_ERR_NULL_PTR);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPReset, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoVPP_Reset(0, nullptr);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
/* Close overview
Terminates current operation and de-allocates any internal memory/structures.
MFX_ERR_NONE The function completed successfully.
*/
TEST(EncodeClose, InitializedEncodeReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxEncParams = { 0 };
mfxEncParams.mfx.CodecId = MFX_CODEC_JPEG;
mfxEncParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxEncParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxEncParams.mfx.FrameInfo.CropW = 128;
mfxEncParams.mfx.FrameInfo.CropH = 96;
mfxEncParams.mfx.FrameInfo.Width = 128;
mfxEncParams.mfx.FrameInfo.Height = 96;
mfxEncParams.mfx.FrameInfo.FrameRateExtN = 30;
mfxEncParams.mfx.FrameInfo.FrameRateExtD = 1;
mfxEncParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY;
sts = MFXVideoENCODE_Init(session, &mfxEncParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoENCODE_Close(session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
ASSERT_EQ(sts, MFX_ERR_NONE);
}
TEST(EncodeClose, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoENCODE_Close(0);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
TEST(DecodeClose, InitializedEncodeReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxDecParams = { 0 };
mfxDecParams.mfx.CodecId = MFX_CODEC_HEVC;
mfxDecParams.IOPattern = MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
mfxDecParams.mfx.FrameInfo.FourCC = MFX_FOURCC_I420;
mfxDecParams.mfx.FrameInfo.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxDecParams.mfx.FrameInfo.CropW = 128;
mfxDecParams.mfx.FrameInfo.CropH = 96;
mfxDecParams.mfx.FrameInfo.Width = 128;
mfxDecParams.mfx.FrameInfo.Height = 96;
sts = MFXVideoDECODE_Init(session, &mfxDecParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoDECODE_Close(session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(DecodeClose, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoDECODE_Close(0);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
TEST(VPPClose, InitializedVPPReturnsErrNone) {
mfxVersion ver = {};
mfxSession session;
mfxStatus sts = MFXInit(MFX_IMPL_SOFTWARE, &ver, &session);
ASSERT_EQ(sts, MFX_ERR_NONE);
mfxVideoParam mfxVPPParams = { 0 };
// Input data
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_I420;
mfxVPPParams.vpp.In.ChromaFormat = MFX_CHROMAFORMAT_YUV420;
mfxVPPParams.vpp.In.CropW = 128;
mfxVPPParams.vpp.In.CropH = 96;
mfxVPPParams.vpp.In.FrameRateExtN = 30;
mfxVPPParams.vpp.In.FrameRateExtD = 1;
mfxVPPParams.vpp.In.Width = mfxVPPParams.vpp.In.CropW;
mfxVPPParams.vpp.In.Height = mfxVPPParams.vpp.In.CropH;
// Output data
mfxVPPParams.vpp.Out = mfxVPPParams.vpp.In;
mfxVPPParams.vpp.In.FourCC = MFX_FOURCC_BGRA;
mfxVPPParams.IOPattern = MFX_IOPATTERN_IN_SYSTEM_MEMORY | MFX_IOPATTERN_OUT_SYSTEM_MEMORY;
sts = MFXVideoVPP_Init(session, &mfxVPPParams);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXVideoVPP_Close(session);
ASSERT_EQ(sts, MFX_ERR_NONE);
sts = MFXClose(session);
EXPECT_EQ(sts, MFX_ERR_NONE);
}
TEST(VPPClose, NullSessionInReturnsInvalidHandle) {
mfxStatus sts = MFXVideoVPP_Close(0);
ASSERT_EQ(sts, MFX_ERR_INVALID_HANDLE);
}
| 37.452213
| 168
| 0.697249
|
wd13384
|
600edb88e66f1e9a3d53f6be9c357d8c3e6b074d
| 3,724
|
cpp
|
C++
|
third-part/7z/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
|
wzaen/soui2
|
30735bbb84184fc26f0e70edbfede889e24fba5b
|
[
"MIT"
] | 33
|
2018-07-04T09:38:12.000Z
|
2021-06-19T06:11:45.000Z
|
third-part/7z/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
|
wzaen/soui2
|
30735bbb84184fc26f0e70edbfede889e24fba5b
|
[
"MIT"
] | null | null | null |
third-part/7z/CPP/7zip/UI/FileManager/RegistryPlugins.cpp
|
wzaen/soui2
|
30735bbb84184fc26f0e70edbfede889e24fba5b
|
[
"MIT"
] | 13
|
2018-07-01T01:55:17.000Z
|
2021-08-03T10:55:45.000Z
|
// RegistryPlugins.cpp
#include "../../../Windows/DLL.h"
#include "../../../Windows/FileFind.h"
#include "../../../Windows/PropVariant.h"
#include "IFolder.h"
#include "RegistryPlugins.h"
using namespace NWindows;
using namespace NFile;
/*
static const TCHAR *kLMBasePath = TEXT("Software\\7-Zip\\FM");
static const TCHAR *kPluginsKeyName = TEXT("Plugins");
static const TCHAR *kPluginsOpenClassIDValue = TEXT("CLSID");
static const TCHAR *kPluginsOptionsClassIDValue = TEXT("Options");
static const TCHAR *kPluginsTypeValue = TEXT("Type");
static CSysString GetFileFolderPluginsKeyName()
{
return CSysString(kLMBasePath) + CSysString(TEXT('\\')) +
CSysString(kPluginsKeyName);
}
*/
typedef UINT32 (WINAPI * GetPluginPropertyFunc)(PROPID propID, PROPVARIANT *value);
static bool ReadPluginInfo(CPluginInfo &pluginInfo, bool needCheckDll)
{
if (needCheckDll)
{
NDLL::CLibrary lib;
if (!lib.LoadEx(pluginInfo.FilePath, LOAD_LIBRARY_AS_DATAFILE))
return false;
}
NDLL::CLibrary lib;
if (!lib.Load(pluginInfo.FilePath))
return false;
GetPluginPropertyFunc getPluginProperty = (GetPluginPropertyFunc)lib.GetProc("GetPluginProperty");
if (getPluginProperty == NULL)
return false;
NCOM::CPropVariant prop;
if (getPluginProperty(NPlugin::kName, &prop) != S_OK)
return false;
if (prop.vt != VT_BSTR)
return false;
pluginInfo.Name = prop.bstrVal;
prop.Clear();
if (getPluginProperty(NPlugin::kClassID, &prop) != S_OK)
return false;
if (prop.vt == VT_EMPTY)
pluginInfo.ClassIDDefined = false;
else if (prop.vt != VT_BSTR)
return false;
else
{
pluginInfo.ClassIDDefined = true;
pluginInfo.ClassID = *(const GUID *)prop.bstrVal;
}
prop.Clear();
if (getPluginProperty(NPlugin::kOptionsClassID, &prop) != S_OK)
return false;
if (prop.vt == VT_EMPTY)
pluginInfo.OptionsClassIDDefined = false;
else if (prop.vt != VT_BSTR)
return false;
else
{
pluginInfo.OptionsClassIDDefined = true;
pluginInfo.OptionsClassID = *(const GUID *)prop.bstrVal;
}
prop.Clear();
if (getPluginProperty(NPlugin::kType, &prop) != S_OK)
return false;
if (prop.vt == VT_EMPTY)
pluginInfo.Type = kPluginTypeFF;
else if (prop.vt == VT_UI4)
pluginInfo.Type = (EPluginType)prop.ulVal;
else
return false;
return true;
}
void ReadPluginInfoList(CObjectVector<CPluginInfo> &plugins)
{
plugins.Clear();
FString baseFolderPrefix = NDLL::GetModuleDirPrefix();
{
CPluginInfo pluginInfo;
pluginInfo.FilePath = baseFolderPrefix + FTEXT("7-zip.dll");
if (::ReadPluginInfo(pluginInfo, false))
plugins.Add(pluginInfo);
}
FString folderPath = baseFolderPrefix + FTEXT("Plugins") FSTRING_PATH_SEPARATOR;
NFind::CEnumerator enumerator(folderPath + FCHAR_ANY_MASK);
NFind::CFileInfo fileInfo;
while (enumerator.Next(fileInfo))
{
if (fileInfo.IsDir())
continue;
CPluginInfo pluginInfo;
pluginInfo.FilePath = folderPath + fileInfo.Name;
if (::ReadPluginInfo(pluginInfo, true))
plugins.Add(pluginInfo);
}
}
void ReadFileFolderPluginInfoList(CObjectVector<CPluginInfo> &plugins)
{
ReadPluginInfoList(plugins);
for (unsigned i = 0; i < plugins.Size();)
if (plugins[i].Type != kPluginTypeFF)
plugins.Delete(i);
else
i++;
{
CPluginInfo p;
// p.FilePath.Empty();
p.Type = kPluginTypeFF;
p.Name = L"7-Zip";
// p.ClassID = CLSID_CAgentArchiveHandler;
p.ClassIDDefined = true;
// p.OptionsClassID;
p.OptionsClassIDDefined = false;
plugins.Add(p);
}
}
| 26.985507
| 101
| 0.667562
|
wzaen
|
6010d295332ffaeb8b43347412f2b95e7f55ad2d
| 209
|
cpp
|
C++
|
src/SeekProcess.cpp
|
stevefolta/dawlet
|
429ffba85f00acf05c15daf2597d97f79cb4f2f2
|
[
"MIT"
] | null | null | null |
src/SeekProcess.cpp
|
stevefolta/dawlet
|
429ffba85f00acf05c15daf2597d97f79cb4f2f2
|
[
"MIT"
] | null | null | null |
src/SeekProcess.cpp
|
stevefolta/dawlet
|
429ffba85f00acf05c15daf2597d97f79cb4f2f2
|
[
"MIT"
] | null | null | null |
#include "SeekProcess.h"
bool SeekProcess::is_done()
{
return state == Done;
}
void SeekProcess::next()
{
switch (state) {
case InEngine:
engine->seek(position);
state = Done;
break;
}
}
| 9.5
| 27
| 0.62201
|
stevefolta
|
6011013701aa982641f9644bb36224a0b8dfd54e
| 19,713
|
cpp
|
C++
|
src/libtriton/format/pe/peOptionalHeader.cpp
|
codesabaka/triton
|
ec90cfc94d86dcfff03d0753ff4ec98154c07d4c
|
[
"BSD-3-Clause"
] | 1
|
2020-11-15T15:21:12.000Z
|
2020-11-15T15:21:12.000Z
|
src/libtriton/format/pe/peOptionalHeader.cpp
|
codesabaka/triton
|
ec90cfc94d86dcfff03d0753ff4ec98154c07d4c
|
[
"BSD-3-Clause"
] | null | null | null |
src/libtriton/format/pe/peOptionalHeader.cpp
|
codesabaka/triton
|
ec90cfc94d86dcfff03d0753ff4ec98154c07d4c
|
[
"BSD-3-Clause"
] | null | null | null |
//! \file
/*
** Copyright (C) - Triton
**
** This program is under the terms of the BSD License.
*/
#include <cstdio>
#include <exceptions.hpp>
#include <peOptionalHeader.hpp>
namespace triton {
namespace format {
namespace pe {
PeOptionalHeader::PeOptionalHeader() {
this->magic = 0;
this->majorLinkerVersion = 0;
this->minorLinkerVersion = 0;
this->sizeOfCode = 0;
this->sizeOfInitializedData = 0;
this->sizeOfUninitializedData = 0;
this->addressOfEntryPoint = 0;
this->baseOfCode = 0;
this->baseOfData = 0;
this->imageBase = 0;
this->sectionAlignment = 0;
this->fileAlignment = 0;
this->majorOperatingSystemVersion = 0;
this->minorOperatingSystemVersion = 0;
this->majorImageVersion = 0;
this->minorImageVersion = 0;
this->majorSubsystemVersion = 0;
this->minorSubsystemVersion = 0;
this->win32VersionValue = 0;
this->sizeOfImage = 0;
this->sizeOfHeaders = 0;
this->checkSum = 0;
this->subsystem = 0;
this->dllCharacteristics = 0;
this->sizeOfStackReserve = 0;
this->sizeOfStackCommit = 0;
this->sizeOfHeapReserve = 0;
this->sizeOfHeapCommit = 0;
this->loaderFlags = 0;
this->numberOfRvaAndSizes = 0;
}
PeOptionalHeader::PeOptionalHeader(const PeOptionalHeader& copy) {
this->magic = copy.magic;
this->majorLinkerVersion = copy.majorLinkerVersion;
this->minorLinkerVersion = copy.minorLinkerVersion;
this->sizeOfCode = copy.sizeOfCode;
this->sizeOfInitializedData = copy.sizeOfInitializedData;
this->sizeOfUninitializedData = copy.sizeOfUninitializedData;
this->addressOfEntryPoint = copy.addressOfEntryPoint;
this->baseOfCode = copy.baseOfCode;
this->baseOfData = copy.baseOfData;
this->imageBase = copy.imageBase;
this->sectionAlignment = copy.sectionAlignment;
this->fileAlignment = copy.fileAlignment;
this->majorOperatingSystemVersion = copy.majorOperatingSystemVersion;
this->minorOperatingSystemVersion = copy.minorOperatingSystemVersion;
this->majorImageVersion = copy.majorImageVersion;
this->minorImageVersion = copy.minorImageVersion;
this->majorSubsystemVersion = copy.majorSubsystemVersion;
this->minorSubsystemVersion = copy.minorSubsystemVersion;
this->win32VersionValue = copy.win32VersionValue;
this->sizeOfImage = copy.sizeOfImage;
this->sizeOfHeaders = copy.sizeOfHeaders;
this->checkSum = copy.checkSum;
this->subsystem = copy.subsystem;
this->dllCharacteristics = copy.dllCharacteristics;
this->sizeOfStackReserve = copy.sizeOfStackReserve;
this->sizeOfStackCommit = copy.sizeOfStackCommit;
this->sizeOfHeapReserve = copy.sizeOfHeapReserve;
this->sizeOfHeapCommit = copy.sizeOfHeapCommit;
this->loaderFlags = copy.loaderFlags;
this->numberOfRvaAndSizes = copy.numberOfRvaAndSizes;
}
PeOptionalHeader::~PeOptionalHeader() {
}
PeOptionalHeader& PeOptionalHeader::operator=(const PeOptionalHeader& copy) {
if (this == ©)
return *this;
this->magic = copy.magic;
this->majorLinkerVersion = copy.majorLinkerVersion;
this->minorLinkerVersion = copy.minorLinkerVersion;
this->sizeOfCode = copy.sizeOfCode;
this->sizeOfInitializedData = copy.sizeOfInitializedData;
this->sizeOfUninitializedData = copy.sizeOfUninitializedData;
this->addressOfEntryPoint = copy.addressOfEntryPoint;
this->baseOfCode = copy.baseOfCode;
this->baseOfData = copy.baseOfData;
this->imageBase = copy.imageBase;
this->sectionAlignment = copy.sectionAlignment;
this->fileAlignment = copy.fileAlignment;
this->majorOperatingSystemVersion = copy.majorOperatingSystemVersion;
this->minorOperatingSystemVersion = copy.minorOperatingSystemVersion;
this->majorImageVersion = copy.majorImageVersion;
this->minorImageVersion = copy.minorImageVersion;
this->majorSubsystemVersion = copy.majorSubsystemVersion;
this->minorSubsystemVersion = copy.minorSubsystemVersion;
this->win32VersionValue = copy.win32VersionValue;
this->sizeOfImage = copy.sizeOfImage;
this->sizeOfHeaders = copy.sizeOfHeaders;
this->checkSum = copy.checkSum;
this->subsystem = copy.subsystem;
this->dllCharacteristics = copy.dllCharacteristics;
this->sizeOfStackReserve = copy.sizeOfStackReserve;
this->sizeOfStackCommit = copy.sizeOfStackCommit;
this->sizeOfHeapReserve = copy.sizeOfHeapReserve;
this->sizeOfHeapCommit = copy.sizeOfHeapCommit;
this->loaderFlags = copy.loaderFlags;
this->numberOfRvaAndSizes = copy.numberOfRvaAndSizes;
return *this;
}
triton::uint32 PeOptionalHeader::getSize(void) const {
if (this->magic == PE_FORMAT_PE32PLUS)
return sizeof(PE32Plus_OptionalHeader);
else
return sizeof(PE32_OptionalHeader);
}
triton::usize PeOptionalHeader::parse(const triton::uint8* raw) {
triton::uint16 peFormat;
std::memcpy(&peFormat, raw, sizeof(peFormat));
if (peFormat == PE_FORMAT_PE32PLUS) {
PE32Plus_OptionalHeader ohdr;
std::memcpy(&ohdr, raw, sizeof(ohdr));
*this = ohdr;
return sizeof(ohdr);
}
else {
PE32_OptionalHeader ohdr;
std::memcpy(&ohdr, raw, sizeof(ohdr));
*this = ohdr;
return sizeof(ohdr);
}
}
void PeOptionalHeader::save(std::ostream& os) const {
if (this->magic == PE_FORMAT_PE32PLUS) {
PE32Plus_OptionalHeader ohdr;
this->assign(ohdr);
os.write(reinterpret_cast<char*>(&ohdr), sizeof(ohdr));
}
else {
PE32_OptionalHeader ohdr;
this->assign(ohdr);
os.write(reinterpret_cast<char*>(&ohdr), sizeof(ohdr));
}
}
triton::uint16 PeOptionalHeader::getMagic(void) const {
return this->magic;
}
triton::uint8 PeOptionalHeader::getMajorLinkerVersion(void) const {
return this->majorLinkerVersion;
}
triton::uint8 PeOptionalHeader::getMinorLinkerVersion(void) const {
return this->minorLinkerVersion;
}
triton::uint32 PeOptionalHeader::getSizeOfCode(void) const {
return this->sizeOfCode;
}
triton::uint32 PeOptionalHeader::getSizeOfInitializedData(void) const {
return this->sizeOfInitializedData;
}
triton::uint32 PeOptionalHeader::getSizeOfUninitializedData(void) const {
return this->sizeOfUninitializedData;
}
triton::uint32 PeOptionalHeader::getAddressOfEntryPoint(void) const {
return this->addressOfEntryPoint;
}
triton::uint32 PeOptionalHeader::getBaseOfCode(void) const {
return this->baseOfCode;
}
triton::uint32 PeOptionalHeader::getBaseOfData(void) const {
return this->baseOfData;
}
triton::uint64 PeOptionalHeader::getImageBase(void) const {
return this->imageBase;
}
triton::uint32 PeOptionalHeader::getSectionAlignment(void) const {
return this->sectionAlignment;
}
triton::uint32 PeOptionalHeader::getFileAlignment(void) const {
return this->fileAlignment;
}
triton::uint16 PeOptionalHeader::getMajorOperatingSystemVersion(void) const {
return this->majorOperatingSystemVersion;
}
triton::uint16 PeOptionalHeader::getMinorOperatingSystemVersion(void) const {
return this->minorOperatingSystemVersion;
}
triton::uint16 PeOptionalHeader::getMajorImageVersion(void) const {
return this->majorImageVersion;
}
triton::uint16 PeOptionalHeader::getMinorImageVersion(void) const {
return this->minorImageVersion;
}
triton::uint16 PeOptionalHeader::getMajorSubsystemVersion(void) const {
return this->majorSubsystemVersion;
}
triton::uint16 PeOptionalHeader::getMinorSubsystemVersion(void) const {
return this->minorSubsystemVersion;
}
triton::uint32 PeOptionalHeader::getWin32VersionValue(void) const {
return this->win32VersionValue;
}
triton::uint32 PeOptionalHeader::getSizeOfImage(void) const {
return this->sizeOfImage;
}
void PeOptionalHeader::setSizeOfImage(triton::uint32 sizeOfImage) {
this->sizeOfImage = sizeOfImage;
}
triton::uint32 PeOptionalHeader::getSizeOfHeaders(void) const {
return this->sizeOfHeaders;
}
void PeOptionalHeader::setSizeOfHeaders(triton::uint32 sizeOfHeaders) {
this->sizeOfHeaders = sizeOfHeaders;
}
triton::uint32 PeOptionalHeader::getCheckSum(void) const {
return this->checkSum;
}
triton::uint16 PeOptionalHeader::getSubsystem(void) const {
return this->subsystem;
}
triton::uint16 PeOptionalHeader::getDllCharacteristics(void) const {
return this->dllCharacteristics;
}
triton::uint64 PeOptionalHeader::getSizeOfStackReserve(void) const {
return this->sizeOfStackReserve;
}
triton::uint64 PeOptionalHeader::getSizeOfStackCommit(void) const {
return this->sizeOfStackCommit;
}
triton::uint64 PeOptionalHeader::getSizeOfHeapReserve(void) const {
return this->sizeOfHeapReserve;
}
triton::uint64 PeOptionalHeader::getSizeOfHeapCommit(void) const {
return this->sizeOfHeapCommit;
}
triton::uint32 PeOptionalHeader::getLoaderFlags(void) const {
return this->loaderFlags;
}
triton::uint32 PeOptionalHeader::getNumberOfRvaAndSizes(void) const {
return this->numberOfRvaAndSizes;
}
PeOptionalHeader& PeOptionalHeader::operator=(const PE32_OptionalHeader& other) {
this->addressOfEntryPoint = other.addressOfEntryPoint;
this->baseOfCode = other.baseOfCode;
this->baseOfData = other.baseOfData;
this->checkSum = other.checkSum;
this->dllCharacteristics = other.dllCharacteristics;
this->fileAlignment = other.fileAlignment;
this->imageBase = other.imageBase;
this->loaderFlags = other.loaderFlags;
this->magic = other.magic;
this->majorImageVersion = other.majorImageVersion;
this->majorLinkerVersion = other.majorLinkerVersion;
this->majorOperatingSystemVersion = other.majorOperatingSystemVersion;
this->majorSubsystemVersion = other.majorSubsystemVersion;
this->minorImageVersion = other.minorImageVersion;
this->minorLinkerVersion = other.minorLinkerVersion;
this->minorOperatingSystemVersion = other.minorOperatingSystemVersion;
this->minorSubsystemVersion = other.minorSubsystemVersion;
this->numberOfRvaAndSizes = other.numberOfRvaAndSizes;
this->sectionAlignment = other.sectionAlignment;
this->sizeOfCode = other.sizeOfCode;
this->sizeOfHeaders = other.sizeOfHeaders;
this->sizeOfHeapCommit = other.sizeOfHeapCommit;
this->sizeOfHeapReserve = other.sizeOfHeapReserve;
this->sizeOfImage = other.sizeOfImage;
this->sizeOfInitializedData = other.sizeOfInitializedData;
this->sizeOfStackCommit = other.sizeOfStackCommit;
this->sizeOfStackReserve = other.sizeOfStackReserve;
this->sizeOfUninitializedData = other.sizeOfUninitializedData;
this->subsystem = other.subsystem;
this->win32VersionValue = other.win32VersionValue;
return *this;
}
PeOptionalHeader& PeOptionalHeader::operator=(const PE32Plus_OptionalHeader& other) {
this->addressOfEntryPoint = other.addressOfEntryPoint;
this->baseOfCode = other.baseOfCode;
this->baseOfData = 0; //not present in this format
this->checkSum = other.checkSum;
this->dllCharacteristics = other.dllCharacteristics;
this->fileAlignment = other.fileAlignment;
this->imageBase = other.imageBase;
this->loaderFlags = other.loaderFlags;
this->magic = other.magic;
this->majorImageVersion = other.majorImageVersion;
this->majorLinkerVersion = other.majorLinkerVersion;
this->majorOperatingSystemVersion = other.majorOperatingSystemVersion;
this->majorSubsystemVersion = other.majorSubsystemVersion;
this->minorImageVersion = other.minorImageVersion;
this->minorLinkerVersion = other.minorLinkerVersion;
this->minorOperatingSystemVersion = other.minorOperatingSystemVersion;
this->minorSubsystemVersion = other.minorSubsystemVersion;
this->numberOfRvaAndSizes = other.numberOfRvaAndSizes;
this->sectionAlignment = other.sectionAlignment;
this->sizeOfCode = other.sizeOfCode;
this->sizeOfHeaders = other.sizeOfHeaders;
this->sizeOfHeapCommit = other.sizeOfHeapCommit;
this->sizeOfHeapReserve = other.sizeOfHeapReserve;
this->sizeOfImage = other.sizeOfImage;
this->sizeOfInitializedData = other.sizeOfInitializedData;
this->sizeOfStackCommit = other.sizeOfStackCommit;
this->sizeOfStackReserve = other.sizeOfStackReserve;
this->sizeOfUninitializedData = other.sizeOfUninitializedData;
this->subsystem = other.subsystem;
this->win32VersionValue = other.win32VersionValue;
return *this;
}
void PeOptionalHeader::assign(PE32_OptionalHeader& other) const {
other.addressOfEntryPoint = this->addressOfEntryPoint;
other.baseOfCode = this->baseOfCode;
other.baseOfData = this->baseOfData;
other.checkSum = this->checkSum;
other.dllCharacteristics = this->dllCharacteristics;
other.fileAlignment = this->fileAlignment;
other.imageBase = this->imageBase;
other.loaderFlags = this->loaderFlags;
other.magic = this->magic;
other.majorImageVersion = this->majorImageVersion;
other.majorLinkerVersion = this->majorLinkerVersion;
other.majorOperatingSystemVersion = this->majorOperatingSystemVersion;
other.majorSubsystemVersion = this->majorSubsystemVersion;
other.minorImageVersion = this->minorImageVersion;
other.minorLinkerVersion = this->minorLinkerVersion;
other.minorOperatingSystemVersion = this->minorOperatingSystemVersion;
other.minorSubsystemVersion = this->minorSubsystemVersion;
other.numberOfRvaAndSizes = this->numberOfRvaAndSizes;
other.sectionAlignment = this->sectionAlignment;
other.sizeOfCode = this->sizeOfCode;
other.sizeOfHeaders = this->sizeOfHeaders;
other.sizeOfHeapCommit = this->sizeOfHeapCommit;
other.sizeOfHeapReserve = this->sizeOfHeapReserve;
other.sizeOfImage = this->sizeOfImage;
other.sizeOfInitializedData = this->sizeOfInitializedData;
other.sizeOfStackCommit = this->sizeOfStackCommit;
other.sizeOfStackReserve = this->sizeOfStackReserve;
other.sizeOfUninitializedData = this->sizeOfUninitializedData;
other.subsystem = this->subsystem;
other.win32VersionValue = this->win32VersionValue;
}
void PeOptionalHeader::assign(PE32Plus_OptionalHeader& other) const {
other.addressOfEntryPoint = this->addressOfEntryPoint;
other.baseOfCode = this->baseOfCode;
other.checkSum = this->checkSum;
other.dllCharacteristics = this->dllCharacteristics;
other.fileAlignment = this->fileAlignment;
other.imageBase = this->imageBase;
other.loaderFlags = this->loaderFlags;
other.magic = this->magic;
other.majorImageVersion = this->majorImageVersion;
other.majorLinkerVersion = this->majorLinkerVersion;
other.majorOperatingSystemVersion = this->majorOperatingSystemVersion;
other.majorSubsystemVersion = this->majorSubsystemVersion;
other.minorImageVersion = this->minorImageVersion;
other.minorLinkerVersion = this->minorLinkerVersion;
other.minorOperatingSystemVersion = this->minorOperatingSystemVersion;
other.minorSubsystemVersion = this->minorSubsystemVersion;
other.numberOfRvaAndSizes = this->numberOfRvaAndSizes;
other.sectionAlignment = this->sectionAlignment;
other.sizeOfCode = this->sizeOfCode;
other.sizeOfHeaders = this->sizeOfHeaders;
other.sizeOfHeapCommit = this->sizeOfHeapCommit;
other.sizeOfHeapReserve = this->sizeOfHeapReserve;
other.sizeOfImage = this->sizeOfImage;
other.sizeOfInitializedData = this->sizeOfInitializedData;
other.sizeOfStackCommit = this->sizeOfStackCommit;
other.sizeOfStackReserve = this->sizeOfStackReserve;
other.sizeOfUninitializedData = this->sizeOfUninitializedData;
other.subsystem = this->subsystem;
other.win32VersionValue = this->win32VersionValue;
}
}; /* pe namespace */
}; /* format namespace */
}; /* triton namespace */
| 41.676533
| 91
| 0.601583
|
codesabaka
|
60124f52773fa9d49e337d3185b9833be2bf9d6e
| 515
|
cpp
|
C++
|
Loyalty/DataModel/Entities/BuyTxDesc.cpp
|
uno-labs-solana-hackathon/core-server
|
fdbdefd32e12fcaa19227f56154e0163c18a35cb
|
[
"Apache-2.0"
] | null | null | null |
Loyalty/DataModel/Entities/BuyTxDesc.cpp
|
uno-labs-solana-hackathon/core-server
|
fdbdefd32e12fcaa19227f56154e0163c18a35cb
|
[
"Apache-2.0"
] | 1
|
2021-03-06T11:38:01.000Z
|
2021-03-15T21:33:16.000Z
|
Loyalty/DataModel/Entities/BuyTxDesc.cpp
|
uno-labs-solana-hackathon/core-server
|
fdbdefd32e12fcaa19227f56154e0163c18a35cb
|
[
"Apache-2.0"
] | null | null | null |
#include "BuyTxDesc.hpp"
namespace Sol::Loyalty::DataModel {
TYPE_STRUCT_IMPLEMENT(BuyTxDesc, GP_MODULE_UUID)
BuyTxDesc::BuyTxDesc (void) noexcept
{
}
BuyTxDesc::~BuyTxDesc (void) noexcept
{
}
void BuyTxDesc::_SCollectStructProps (GpTypePropInfo::C::Vec::Val& aPropsOut)
{
PROP(id);
PROP(items);
PROP(create_ts);
PROP(client_id);
PROP(total);
PROP(earned);
PROP(spend);
PROP(spend_sign);
PROP(spend_raw_tx);
PROP(new_account_sign);
PROP(new_account_raw_tx);
}
}//namespace Sol::Loyalty::DataModel
| 16.612903
| 77
| 0.743689
|
uno-labs-solana-hackathon
|
6013cd3b9f85f93d7c99e790ff95d7ac72ebf5de
| 1,261
|
cc
|
C++
|
src/utl/tsk_js_c_opts.cc
|
FRG-UPC-Deliverables/tsk-js
|
9dd4fcd1c88cb690361cc2a8429cdd127684acea
|
[
"MIT"
] | null | null | null |
src/utl/tsk_js_c_opts.cc
|
FRG-UPC-Deliverables/tsk-js
|
9dd4fcd1c88cb690361cc2a8429cdd127684acea
|
[
"MIT"
] | 5
|
2021-05-08T07:21:28.000Z
|
2021-09-21T03:54:39.000Z
|
src/utl/tsk_js_c_opts.cc
|
FRG-UPC-Deliverables/tsk-js
|
9dd4fcd1c88cb690361cc2a8429cdd127684acea
|
[
"MIT"
] | null | null | null |
#include "tsk_js_utl.h"
#include <string.h>
namespace tsk_js {
using v8::Isolate;
using v8::HandleScope;
using v8::Local;
using v8::Object;
using v8::Number;
using v8::String;
using v8::Boolean;
using v8::Value;
// -----------------------------
// --- B a s e O b j e c t ---
// -----------------------------
TskConstructionOptions::TskConstructionOptions(Isolate *isolate) :
_isolate(isolate), _imgfile(NULL)
{
}
TskConstructionOptions::~TskConstructionOptions()
{
if (this->_imgfile) {
free(this->_imgfile);
}
}
// -----------------------------------
// --- O b j e c t M e t h o d s ---
// -----------------------------------
int
TskConstructionOptions::Initialize(Local<String> imgfile)
{
int length;
String::Utf8Value string(imgfile);
length = string.length() + 1;
#ifdef USE_WCHAR_TSK_CHAR
this->_imgfile = new WCHAR[length];
MultiByteToWideChar(CP_ACP, 0, *string, -1, (LPWCH) this->_imgfile, length);
#else
this->_imgfile = (TSK_TCHAR *)malloc(length);
memcpy(this->_imgfile, *string, length);
#endif
return 1;
}
Isolate *
TskConstructionOptions::GetIsolate()
{
return this->_isolate;
}
const TSK_TCHAR *
TskConstructionOptions::GetImgfile()
{
return this->_imgfile;
}
}
| 17.513889
| 80
| 0.596352
|
FRG-UPC-Deliverables
|
601cbb05fa4c299c79eaee4848350840ea6c9000
| 4,022
|
cpp
|
C++
|
src/Nes.cpp
|
amaiorano/nes-emu
|
6e4e446d8eee923de48db6e2a2c800b38dfb333e
|
[
"MIT"
] | 54
|
2015-03-24T14:05:12.000Z
|
2022-03-24T14:03:01.000Z
|
src/Nes.cpp
|
amaiorano/nes-emu
|
6e4e446d8eee923de48db6e2a2c800b38dfb333e
|
[
"MIT"
] | 3
|
2015-02-03T17:43:26.000Z
|
2020-11-12T19:56:01.000Z
|
src/Nes.cpp
|
amaiorano/nes-emu
|
6e4e446d8eee923de48db6e2a2c800b38dfb333e
|
[
"MIT"
] | 18
|
2015-02-01T15:27:27.000Z
|
2021-07-19T04:17:16.000Z
|
#include "Nes.h"
#include "Stream.h"
#include "Rom.h"
#include "System.h"
#include "Serializer.h"
#include "Renderer.h"
#include "IO.h"
#include "CircularBuffer.h"
Nes::~Nes()
{
// Save sram on exit
SerializeSaveRam(true);
}
void Nes::Initialize()
{
m_apu.Initialize();
m_cpu.Initialize(m_cpuMemoryBus, m_apu);
m_ppu.Initialize(m_ppuMemoryBus, *this);
m_cartridge.Initialize(*this);
m_cpuInternalRam.Initialize();
m_cpuMemoryBus.Initialize(m_cpu, m_ppu, m_cartridge, m_cpuInternalRam);
m_ppuMemoryBus.Initialize(m_ppu, m_cartridge);
m_turbo = false;
// Create directories
const std::string& appDir = System::GetAppDirectory();
m_saveDir = appDir + "saves/";
System::CreateDirectory(m_saveDir.c_str());
}
RomHeader Nes::LoadRom(const char* file)
{
// Save sram of current cart before loading a new one
SerializeSaveRam(true);
m_romName = IO::Path::GetFileNameWithoutExtension(file);
// Load rom and last sram state, if any
RomHeader romHeader = m_cartridge.LoadRom(file);
SerializeSaveRam(false);
// Initialize rewind buffer
m_rewindManager.Initialize(*this);
return romHeader;
}
void Nes::Reset()
{
m_frameTimer.Reset();
m_cpu.Reset();
m_ppu.Reset();
m_apu.Reset();
//@TODO: Maybe reset cartridge (and mapper)?
m_lastSaveRamTime = System::GetTimeSec();
}
void Nes::SerializeSaveRam(bool save)
{
if (!m_cartridge.IsRomLoaded())
return;
assert(!m_romName.empty());
const std::string& saveRamePath = m_saveDir + m_romName + ".sav";
if (save)
{
m_cartridge.WriteSaveRamFile(saveRamePath.c_str());
}
else
{
m_cartridge.LoadSaveRamFile(saveRamePath.c_str());
}
}
bool Nes::SerializeSaveState(bool save)
{
const std::string& saveStatePath = m_saveDir + m_romName + ".st0";
try
{
if (save)
{
FileStream fs;
if (!fs.Open(saveStatePath.c_str(), "wb"))
throw std::logic_error("Failed to open file for save");
Serializer::SaveRootObject(fs, *this);
}
else
{
FileStream fs;
if (!fs.Open(saveStatePath.c_str(), "rb"))
{
throw std::logic_error("Failed to open file for load");
}
Reset();
Serializer::LoadRootObject(fs, *this);
// Clear rewind states so user can't rewind to before this save state was loaded
m_rewindManager.ClearRewindStates();
}
printf("%s SaveState: %s\n", save ? "Saved" : "Loaded", saveStatePath.c_str());
return true;
}
catch (const std::exception& ex)
{
printf("Failed to %s SaveState: %s, Reason: %s\n", save ? "Save" : "Load", saveStatePath.c_str(), ex.what());
}
return false;
}
void Nes::Serialize(class Serializer& serializer)
{
SERIALIZE(m_turbo);
serializer.SerializeObject(m_cpu);
serializer.SerializeObject(m_ppu);
serializer.SerializeObject(m_apu);
serializer.SerializeObject(m_cartridge);
serializer.SerializeObject(m_cpuInternalRam);
}
void Nes::RewindSaveStates(bool enable)
{
m_rewindManager.SetRewinding(enable);
}
void Nes::ExecuteFrame(bool paused)
{
if (m_rewindManager.IsRewinding())
{
if (m_rewindManager.RewindFrame())
{
// Execute a single frame so that we can render it and play audio
ExecuteCpuAndPpuFrame();
m_ppu.RenderFrame();
}
return;
}
if (!paused)
{
ExecuteCpuAndPpuFrame();
m_ppu.RenderFrame();
m_rewindManager.SaveRewindState();
}
// Just rendered a screen; FrameTimer will wait until we hit 60 FPS (if machine is too fast).
// If turbo mode is enabled, it won't wait.
const float32 minFrameTime = 1.0f/60.0f;
m_frameTimer.Update(m_turbo? 0.f: minFrameTime);
// Auto-save sram at fixed intervals
const float64 saveInterval = 5.0;
const float64 currTime = System::GetTimeSec();
if (currTime - m_lastSaveRamTime >= saveInterval)
{
SerializeSaveRam(true);
m_lastSaveRamTime = currTime;
}
}
void Nes::ExecuteCpuAndPpuFrame()
{
bool completedFrame = false;
while (!completedFrame)
{
// Update CPU, get number of cycles elapsed
uint32 cpuCycles;
m_cpu.Execute(cpuCycles);
// Update PPU with that many cycles
m_ppu.Execute(cpuCycles, completedFrame);
m_apu.Execute(cpuCycles);
}
}
| 21.740541
| 111
| 0.712829
|
amaiorano
|
6020b30a6da64902670d8e8d93a3c43c8c701135
| 1,579
|
cpp
|
C++
|
src/python/PyImath/PyImathBox2Array.cpp
|
JenusL/Imath
|
749a1bfe017b2daccb3eb9759fbe837ea4718a0a
|
[
"BSD-3-Clause"
] | 156
|
2020-06-14T06:29:06.000Z
|
2022-03-29T22:55:55.000Z
|
src/python/PyImath/PyImathBox2Array.cpp
|
JenusL/Imath
|
749a1bfe017b2daccb3eb9759fbe837ea4718a0a
|
[
"BSD-3-Clause"
] | 146
|
2020-06-13T18:17:33.000Z
|
2022-03-28T16:47:29.000Z
|
src/python/PyImath/PyImathBox2Array.cpp
|
JenusL/Imath
|
749a1bfe017b2daccb3eb9759fbe837ea4718a0a
|
[
"BSD-3-Clause"
] | 48
|
2020-06-16T18:44:16.000Z
|
2022-03-24T20:50:06.000Z
|
//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//
// clang-format off
#include "PyImathBoxArrayImpl.h"
#include "PyImathExport.h"
namespace PyImath {
using namespace boost::python;
template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Box2s> > register_BoxArray<IMATH_NAMESPACE::V2s>();
template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Box2i> > register_BoxArray<IMATH_NAMESPACE::V2i>();
template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Box2i64> > register_BoxArray<IMATH_NAMESPACE::V2i64>();
template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Box2f> > register_BoxArray<IMATH_NAMESPACE::V2f>();
template PYIMATH_EXPORT class_<FixedArray<IMATH_NAMESPACE::Box2d> > register_BoxArray<IMATH_NAMESPACE::V2d>();
template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2s PyImath::FixedArrayDefaultValue<IMATH_NAMESPACE::Box2s>::value() { return IMATH_NAMESPACE::Box2s(); }
template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2i PyImath::FixedArrayDefaultValue<IMATH_NAMESPACE::Box2i>::value() { return IMATH_NAMESPACE::Box2i(); }
template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2i64 PyImath::FixedArrayDefaultValue<IMATH_NAMESPACE::Box2i64>::value() { return IMATH_NAMESPACE::Box2i64(); }
template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2f PyImath::FixedArrayDefaultValue<IMATH_NAMESPACE::Box2f>::value() { return IMATH_NAMESPACE::Box2f(); }
template<> PYIMATH_EXPORT IMATH_NAMESPACE::Box2d PyImath::FixedArrayDefaultValue<IMATH_NAMESPACE::Box2d>::value() { return IMATH_NAMESPACE::Box2d(); }
}
| 60.730769
| 156
| 0.79734
|
JenusL
|
e741e5e46ed8a9522b78aa49d8b2608048a33145
| 32,085
|
cpp
|
C++
|
squid/test/unit/test_parameter.cpp
|
patrick-rotsaert/squid
|
385159c17924d910c0f8a966b4b5dc531b0c1d49
|
[
"BSL-1.0"
] | null | null | null |
squid/test/unit/test_parameter.cpp
|
patrick-rotsaert/squid
|
385159c17924d910c0f8a966b4b5dc531b0c1d49
|
[
"BSL-1.0"
] | null | null | null |
squid/test/unit/test_parameter.cpp
|
patrick-rotsaert/squid
|
385159c17924d910c0f8a966b4b5dc531b0c1d49
|
[
"BSL-1.0"
] | null | null | null |
#include <gtest/gtest.h>
#include <squid/parameter.h>
namespace squid {
TEST(ParameterTest, ByValueConstructFromScalars)
{
#define TEST_CONSTRUCT_FROM_SCALAR(TYPE, VALUE) \
do \
{ \
{ \
TYPE src{ VALUE }; \
Parameter x{ src, Parameter::ByValue{} }; \
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value())); \
const auto& value = std::get<Parameter::value_type>(x.value()); \
EXPECT_TRUE(std::holds_alternative<TYPE>(value)); \
const auto& evalue = std::get<TYPE>(value); \
EXPECT_EQ(evalue, src); \
} \
{ \
Parameter x{ static_cast<TYPE>(VALUE), Parameter::ByValue{} }; \
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value())); \
const auto& value = std::get<Parameter::value_type>(x.value()); \
EXPECT_TRUE(std::holds_alternative<TYPE>(value)); \
const auto& evalue = std::get<TYPE>(value); \
EXPECT_EQ(evalue, static_cast<TYPE>(VALUE)); \
} \
} while (false)
TEST_CONSTRUCT_FROM_SCALAR(bool, true);
TEST_CONSTRUCT_FROM_SCALAR(char, 'A');
TEST_CONSTRUCT_FROM_SCALAR(signed char, 42);
TEST_CONSTRUCT_FROM_SCALAR(unsigned char, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::int16_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::uint16_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::int32_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::uint32_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::int64_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(std::uint64_t, 42);
TEST_CONSTRUCT_FROM_SCALAR(float, 42);
TEST_CONSTRUCT_FROM_SCALAR(double, 42);
TEST_CONSTRUCT_FROM_SCALAR(long double, 42);
}
TEST(ParameterTest, ByValueConstructFromEnum)
{
enum Enum
{
FIRST,
SECOND
} src{};
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::underlying_type_t<Enum>>(value));
}
TEST(ParameterTest, ByValueConstructFromEnumClassInteger)
{
enum class Enum : int
{
FIRST,
SECOND
} src{};
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::underlying_type_t<Enum>>(value));
}
TEST(ParameterTest, ByValueConstructFromEnumClassChar)
{
enum class Enum : char
{
FIRST = 'A',
SECOND = 'B'
} src{ Enum::SECOND };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<char>(value));
const auto& evalue = std::get<char>(value);
EXPECT_EQ(evalue, 'B');
}
TEST(ParameterTest, ByValueConstructFromString)
{
{
std::string src{ "foo" };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::string>(value));
const auto& evalue = std::get<std::string>(value);
EXPECT_EQ(evalue, src);
}
{
std::string src{ "foo" };
Parameter x{ std::string{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::string>(value));
const auto& evalue = std::get<std::string>(value);
EXPECT_EQ(evalue, src);
}
}
TEST(ParameterTest, ByValueConstructFromStringView)
{
{
std::string_view src{ "foo" };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::string_view>(value));
const auto& evalue = std::get<std::string_view>(value);
EXPECT_EQ(evalue, src);
EXPECT_EQ(evalue.data(), src.data());
}
{
std::string_view src{ "foo" };
Parameter x{ std::string_view{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::string_view>(value));
const auto& evalue = std::get<std::string_view>(value);
EXPECT_EQ(evalue, src);
EXPECT_EQ(evalue.data(), src.data());
}
}
TEST(ParameterTest, ByValueConstructFromCharPointer)
{
const char* src{ "foo" };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::string_view>(value));
const auto& evalue = std::get<std::string_view>(value);
EXPECT_EQ(evalue, src);
EXPECT_EQ(evalue.data(), src);
EXPECT_EQ(evalue.length(), 3);
}
TEST(ParameterTest, ByValueConstructFromByteString)
{
{
byte_string src{ reinterpret_cast<const unsigned char*>("foo"), 3 };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<byte_string>(value));
const auto& evalue = std::get<byte_string>(value);
EXPECT_EQ(evalue, src);
}
{
byte_string src{ reinterpret_cast<const unsigned char*>("foo"), 3 };
Parameter x{ byte_string{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<byte_string>(value));
const auto& evalue = std::get<byte_string>(value);
EXPECT_EQ(evalue, src);
}
}
TEST(ParameterTest, ByValueConstructFromByteStringView)
{
{
byte_string_view src{ reinterpret_cast<const unsigned char*>("foo"), 3 };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<byte_string_view>(value));
const auto& evalue = std::get<byte_string_view>(value);
EXPECT_EQ(evalue, src);
EXPECT_EQ(evalue.data(), src.data());
}
{
byte_string_view src{ reinterpret_cast<const unsigned char*>("foo"), 3 };
Parameter x{ byte_string_view{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<byte_string_view>(value));
const auto& evalue = std::get<byte_string_view>(value);
EXPECT_EQ(evalue, src);
EXPECT_EQ(evalue.data(), src.data());
}
}
TEST(ParameterTest, ByValueConstructFromTimePoint)
{
{
time_point src{ std::chrono::system_clock::now() };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<time_point>(value));
const auto& evalue = std::get<time_point>(value);
EXPECT_EQ(evalue, src);
}
{
time_point src{ std::chrono::system_clock::now() };
Parameter x{ time_point{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<time_point>(value));
const auto& evalue = std::get<time_point>(value);
EXPECT_EQ(evalue, src);
}
}
TEST(ParameterTest, ByValueConstructFromDate)
{
{
date src{ std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<date>(value));
const auto& evalue = std::get<date>(value);
EXPECT_EQ(evalue, src);
}
{
date src{ std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) };
Parameter x{ date{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<date>(value));
const auto& evalue = std::get<date>(value);
EXPECT_EQ(evalue, src);
}
}
TEST(ParameterTest, ByValueConstructFromTimeOfDay)
{
{
time_of_day src{ std::chrono::hours{ 12 } };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<time_of_day>(value));
const auto& evalue = std::get<time_of_day>(value);
EXPECT_EQ(evalue.to_duration(), src.to_duration());
}
{
time_of_day src{ std::chrono::hours{ 12 } };
Parameter x{ time_of_day{ src }, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<time_of_day>(value));
const auto& evalue = std::get<time_of_day>(value);
EXPECT_EQ(evalue.to_duration(), src.to_duration());
}
}
TEST(ParameterTest, ByValueConstructFromStdOptionalWithoutValue)
{
{
std::optional<int> src{ std::nullopt };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::nullopt_t>(value));
}
{
Parameter x{ std::nullopt, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<std::nullopt_t>(value));
}
}
TEST(ParameterTest, ByValueConstructFromStdOptionalWithValue)
{
std::optional<int> src{ 42 };
Parameter x{ src, Parameter::ByValue{} };
EXPECT_TRUE(std::holds_alternative<Parameter::value_type>(x.value()));
const auto& value = std::get<Parameter::value_type>(x.value());
EXPECT_TRUE(std::holds_alternative<int>(value));
const auto& evalue = std::get<int>(value);
EXPECT_EQ(evalue, src);
}
TEST(ParameterTest, ByReferenceConstructFromNonOptional)
{
int src{ 42 };
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_type>(ref));
const auto& ptr = std::get<Parameter::pointer_type>(ref);
EXPECT_TRUE(std::holds_alternative<const int*>(ptr));
const auto& eptr = std::get<const int*>(ptr);
EXPECT_EQ(eptr, &src);
}
TEST(ParameterTest, ByReferenceConstructFromEnum)
{
{
enum Enum
{
FIRST,
SECOND
} src{};
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_type>(ref));
const auto& ptr = std::get<Parameter::pointer_type>(ref);
using enum_underlying_type = std::underlying_type_t<Enum>;
EXPECT_TRUE(std::holds_alternative<const enum_underlying_type*>(ptr));
const auto& eptr = std::get<const enum_underlying_type*>(ptr);
EXPECT_EQ(reinterpret_cast<const Enum*>(eptr), &src);
}
{
enum Enum
{
FIRST,
SECOND
};
std::optional<Enum> src;
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_optional_type>(ref));
const auto& ptr = std::get<Parameter::pointer_optional_type>(ref);
using enum_underlying_type = std::underlying_type_t<Enum>;
EXPECT_TRUE(std::holds_alternative<const std::optional<enum_underlying_type>*>(ptr));
const auto& eptr = std::get<const std::optional<enum_underlying_type>*>(ptr);
EXPECT_EQ(reinterpret_cast<const std::optional<Enum>*>(eptr), &src);
}
{
enum class Enum : char
{
FIRST = 'A',
SECOND = 'B'
} src{};
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_type>(ref));
const auto& ptr = std::get<Parameter::pointer_type>(ref);
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ(reinterpret_cast<const Enum*>(eptr), &src);
}
{
enum class Enum : char
{
FIRST = 'A',
SECOND = 'B'
};
std::optional<Enum> src;
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_optional_type>(ref));
const auto& ptr = std::get<Parameter::pointer_optional_type>(ref);
EXPECT_TRUE(std::holds_alternative<const std::optional<char>*>(ptr));
const auto& eptr = std::get<const std::optional<char>*>(ptr);
EXPECT_EQ(reinterpret_cast<const std::optional<Enum>*>(eptr), &src);
}
}
TEST(ParameterTest, ByReferenceConstructFromStdOptional)
{
std::optional<int> src{ 42 };
Parameter x{ src, Parameter::ByReference{} };
EXPECT_TRUE(std::holds_alternative<Parameter::reference_type>(x.value()));
const auto& ref = std::get<Parameter::reference_type>(x.value());
EXPECT_TRUE(std::holds_alternative<Parameter::pointer_optional_type>(ref));
const auto& ptr = std::get<Parameter::pointer_optional_type>(ref);
EXPECT_TRUE(std::holds_alternative<const std::optional<int>*>(ptr));
const auto& eptr = std::get<const std::optional<int>*>(ptr);
EXPECT_EQ(eptr, &src);
}
TEST(ParameterTest, TestPointerGetter)
{
#define TEST_POINTER_GETTER(TYPE, VALUE) \
do \
{ \
{ \
TYPE src{ VALUE }; \
Parameter x{ src, Parameter::ByValue{} }; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_NE(eptr, nullptr); \
EXPECT_NE(eptr, &src); \
EXPECT_EQ(*eptr, src); \
} \
\
{ \
std::optional<TYPE> src{ std::nullopt }; \
Parameter x{ src, Parameter::ByValue{} }; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr)); \
} \
\
{ \
TYPE src{ VALUE }; \
Parameter x{ src, Parameter::ByReference{} }; \
{ \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_EQ(eptr, &src); \
} \
{ \
TYPE deflt{}; \
src = deflt; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_EQ(eptr, &src); \
} \
} \
\
{ \
std::optional<TYPE> src{ VALUE }; \
Parameter x{ src, Parameter::ByReference{} }; \
{ \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_EQ(eptr, &src.value()); \
} \
{ \
TYPE deflt{}; \
src = deflt; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_EQ(eptr, &src.value()); \
} \
{ \
src = std::nullopt; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr)); \
} \
} \
\
{ \
std::optional<TYPE> src{ std::nullopt }; \
Parameter x{ src, Parameter::ByReference{} }; \
{ \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr)); \
} \
{ \
src = VALUE; \
const auto ptr = x.pointer(); \
EXPECT_TRUE(std::holds_alternative<const TYPE*>(ptr)); \
const auto& eptr = std::get<const TYPE*>(ptr); \
EXPECT_EQ(eptr, &src.value()); \
} \
} \
} while (false)
byte_string_view bsv{ reinterpret_cast<const unsigned char*>("foo"), 3 };
TEST_POINTER_GETTER(bool, true);
TEST_POINTER_GETTER(char, 'A');
TEST_POINTER_GETTER(signed char, 42);
TEST_POINTER_GETTER(unsigned char, 42);
TEST_POINTER_GETTER(std::int16_t, 42);
TEST_POINTER_GETTER(std::uint16_t, 42);
TEST_POINTER_GETTER(std::int32_t, 42);
TEST_POINTER_GETTER(std::uint32_t, 42);
TEST_POINTER_GETTER(std::int64_t, 42);
TEST_POINTER_GETTER(std::uint64_t, 42);
TEST_POINTER_GETTER(float, 42);
TEST_POINTER_GETTER(double, 42);
TEST_POINTER_GETTER(long double, 42);
TEST_POINTER_GETTER(std::string_view, "42");
TEST_POINTER_GETTER(std::string, "42");
TEST_POINTER_GETTER(byte_string_view, bsv);
TEST_POINTER_GETTER(byte_string, bsv);
TEST_POINTER_GETTER(time_point, std::chrono::system_clock::now());
// These do not have an operator== :(
//TEST_POINTER_GETTER(date, std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()));
//TEST_POINTER_GETTER(time_of_day, std::chrono::hours{ 12 });
}
TEST(ParameterTest, TestPointerGetterEnum)
{
enum Enum
{
FIRST,
SECOND
};
using base = std::underlying_type_t<Enum>;
{
Enum src{ FIRST };
Parameter x{ src, Parameter::ByValue{} };
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_NE(eptr, nullptr);
EXPECT_NE((void*)(eptr), (void*)(&src));
EXPECT_EQ(*eptr, src);
}
{
std::optional<Enum> src{ std::nullopt };
Parameter x{ src, Parameter::ByValue{} };
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
{
Enum src{ FIRST };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src));
}
{
src = SECOND;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src));
}
}
{
std::optional<Enum> src{ FIRST };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
{
src = SECOND;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
{
src = std::nullopt;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
}
{
std::optional<Enum> src{ std::nullopt };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
{
src = FIRST;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const base*>(ptr));
const auto& eptr = std::get<const base*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
}
}
TEST(ParameterTest, TestPointerGetterEnumChar)
{
enum class Enum : char
{
FIRST = 'A',
SECOND = 'B'
};
{
Enum src{ Enum::FIRST };
Parameter x{ src, Parameter::ByValue{} };
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_NE(eptr, nullptr);
EXPECT_NE((void*)(eptr), (void*)(&src));
EXPECT_EQ(*eptr, (char)src);
}
{
std::optional<Enum> src{ std::nullopt };
Parameter x{ src, Parameter::ByValue{} };
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
{
Enum src{ Enum::FIRST };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src));
}
{
src = Enum::SECOND;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src));
}
}
{
std::optional<Enum> src{ Enum::FIRST };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
{
src = Enum::SECOND;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
{
src = std::nullopt;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
}
{
std::optional<Enum> src{ std::nullopt };
Parameter x{ src, Parameter::ByReference{} };
{
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const std::nullopt_t*>(ptr));
}
{
src = Enum::FIRST;
const auto ptr = x.pointer();
EXPECT_TRUE(std::holds_alternative<const char*>(ptr));
const auto& eptr = std::get<const char*>(ptr);
EXPECT_EQ((void*)(eptr), (void*)(&src.value()));
}
}
}
} // namespace squid
| 48.835616
| 140
| 0.463519
|
patrick-rotsaert
|
e74758b9c44dd3fd33ec02416c67fe0ff297a090
| 15,805
|
cpp
|
C++
|
tests/test_selu.cpp
|
Arech/nntl
|
fdcd7f33216c6414547acea3c4c172734ef9412a
|
[
"BSD-3-Clause"
] | 12
|
2015-12-22T19:55:56.000Z
|
2020-05-28T13:10:19.000Z
|
tests/test_selu.cpp
|
Arech/nntl
|
fdcd7f33216c6414547acea3c4c172734ef9412a
|
[
"BSD-3-Clause"
] | null | null | null |
tests/test_selu.cpp
|
Arech/nntl
|
fdcd7f33216c6414547acea3c4c172734ef9412a
|
[
"BSD-3-Clause"
] | 1
|
2017-10-15T11:12:33.000Z
|
2017-10-15T11:12:33.000Z
|
/*
This file is a part of NNTL project (https://github.com/Arech/nntl)
Copyright (c) 2015-2021, Arech (aradvert@gmail.com; https://github.com/Arech)
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of NNTL nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// tests.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
//to get rid of '... decorated name length exceeded, name was truncated'
#pragma warning( disable : 4503 )
#include "../nntl/nntl.h"
#include "../nntl/_supp/io/binfile.h"
#include "../nntl/_supp/io/matfile.h"
#include "../nntl/weights_init/LsuvExt.h"
#include "asserts.h"
#include "common_routines.h"
#include "nn_base_arch.h"
using namespace nntl;
template<typename ArchPrmsT>
struct GC_ALPHADROPOUT : public nntl_tests::NN_base_arch_td<ArchPrmsT> {
typedef nntl::LFC_DO<activation::selu<real_t>, myGradWorks> testedLFC;
testedLFC lFinal;
~GC_ALPHADROPOUT()noexcept {}
GC_ALPHADROPOUT(const ArchPrms_t& Prms)noexcept
: lFinal(100, Prms.learningRate, "lFinal")
{
lFinal.dropoutPercentActive(Prms.specialDropoutAlivePerc);
}
};
TEST(TestSelu, GradCheck_alphaDropout) {
#pragma warning(disable:4459)
typedef double real_t;
typedef nntl_tests::NN_base_params<real_t, nntl::inspector::GradCheck<real_t>> ArchPrms_t;
#pragma warning(default:4459)
nntl::inmem_train_data<real_t> td;
readTd(td);
ArchPrms_t Prms(td);
Prms.specialDropoutAlivePerc = real_t(.75);
nntl_tests::NN_arch<GC_ALPHADROPOUT<ArchPrms_t>> nnArch(Prms);
auto ec = nnArch.warmup(td, 5, 200);
ASSERT_EQ(decltype(nnArch)::ErrorCode_t::Success, ec) << "Reason: " << nnArch.NN.get_error_str(ec);
gradcheck_settings<real_t> ngcSetts(true, true, 1e-4);
//ngcSetts.evalSetts.bIgnoreZerodLdWInUndelyingLayer = true;
ngcSetts.evalSetts.dLdW_setts.relErrFailThrsh = real_t(1e-1);//big error is possible due to selu derivative kink :(
//need some handling for it :(
STDCOUTL("*** WARNING: there's no handling of SELU discontinious derivative, therefore occational failures are possible :(");
ngcSetts.evalSetts.dLdA_setts.percOfZeros = 70;
ngcSetts.evalSetts.dLdW_setts.percOfZeros = 70;
ASSERT_TRUE(nnArch.NN.gradcheck(td.train_x(), td.train_y(), 5, ngcSetts));
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
#pragma warning(push,3)
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/variance.hpp>
#pragma warning(pop)
template<typename RealT, bool bAdjustForSampleVar>
struct inspector_act_var_checker : public inspector::_impl::_base<RealT> {
protected:
typedef utils::layer_idx_keeper<layer_index_t, _NoLayerIdxSpecified, 32> keeper_t;
keeper_t m_curLayer;
layer_index_t m_lastLayerIdxToCheck;
//note that we don't compare variances, calculated with different algos now. We just need precise variance value, and no more
typedef ::boost::accumulators::accumulator_set<ext_real_t
, ::boost::accumulators::stats<
::boost::accumulators::tag::mean
, ::boost::accumulators::tag::lazy_variance
>
> stats_t;
struct layers_stats_t {
stats_t sMean;
stats_t sVar;
};
typedef ::std::vector<layers_stats_t> a_layers_stat_t;
a_layers_stat_t m_layersStats;
void _calc_neuronwise_stats(const realmtx_t& act, const layer_index_t lidx)noexcept {
auto& lStats = m_layersStats[lidx];
const ptrdiff_t tr = act.rows();
auto pA = act.data();
const auto pAE = act.colDataAsVec(act.cols_no_bias());
NNTL_ASSERT(tr > 1);
const ext_real_t adjVar = bAdjustForSampleVar ? (static_cast<ext_real_t>(tr) / (tr - 1)) : ext_real_t(1);
while (pA != pAE) {
stats_t st;
const auto pAEr = pA + tr;
while (pA != pAEr) {
st(*pA++);
}
lStats.sMean(::boost::accumulators::extract_result<::boost::accumulators::tag::mean>(st));
lStats.sVar(adjVar*::boost::accumulators::extract_result<::boost::accumulators::tag::lazy_variance>(st));
}
}
public:
void init_nnet(const size_t totalLayers, const numel_cnt_t totalEpochs)noexcept {
NNTL_UNREF(totalEpochs);
m_lastLayerIdxToCheck = static_cast<layer_index_t>(totalLayers - 2);
m_layersStats.resize(totalLayers - 1);
}
void fprop_begin(const layer_index_t lIdx, const realmtx_t& prevAct, const bool bTrainingMode) noexcept {
NNTL_UNREF(prevAct); NNTL_UNREF(bTrainingMode);
m_curLayer.push(lIdx);
}
void fprop_end(const realmtx_t& act) noexcept {
if (m_curLayer <= m_lastLayerIdxToCheck) {
_calc_neuronwise_stats(act, m_curLayer);
}
m_curLayer.pop();
}
template<typename base_t> struct stats_EPS {};
template<> struct stats_EPS<double> {
static constexpr double mean_eps = .07;
static constexpr double var_eps = .17;
};
template<> struct stats_EPS<float> {
static constexpr float mean_eps = .07f;
static constexpr float var_eps = .17f;
};
void report_stats(bool bDoAsserts = true)const noexcept {
for (unsigned i = 0; i <= m_lastLayerIdxToCheck; ++i) {
STDCOUTL("Reporting data distribution for layer#" << i << (i ? " -- SELU" : " -- input data"));
const auto& lStats = m_layersStats[i];
const ext_real_t _cnt = static_cast<ext_real_t>(::boost::accumulators::count(lStats.sMean));
NNTL_ASSERT(_cnt > 1);
const ext_real_t adjVar = bAdjustForSampleVar ? (_cnt / (_cnt - 1)) : ext_real_t(1);
const auto mean_of_mean = ::boost::accumulators::extract_result<::boost::accumulators::tag::mean>(lStats.sMean);
const auto var_of_mean = adjVar*::boost::accumulators::extract_result<::boost::accumulators::tag::lazy_variance>(lStats.sMean);
const auto mean_of_var = ::boost::accumulators::extract_result<::boost::accumulators::tag::mean>(lStats.sVar);
const auto var_of_var = adjVar*::boost::accumulators::extract_result<::boost::accumulators::tag::lazy_variance>(lStats.sVar);
printf_s("mean = %05.3f +/- %06.4f, variance = %05.3f +/- %06.4f\n", mean_of_mean, ::std::sqrt(var_of_mean)
, mean_of_var, ::std::sqrt(var_of_var));
if (bDoAsserts) {
//real_t is a type of underlying data, but we compare calculated statistics value with pre-set value, so with ext_real_t
ASSERT_NEAR(mean_of_mean, ext_real_t(0), stats_EPS<real_t>::mean_eps);
ASSERT_NEAR(mean_of_var, ext_real_t(1), stats_EPS<real_t>::var_eps);
}
}
}
};
template<typename iRngT>
void _test_selu_make_td(inmem_train_data< typename iRngT::real_t >& td, const vec_len_t tr_cnt, const neurons_count_t xwidth, iRngT& iR)noexcept
{
typedef typename iRngT::real_t real_t;
typedef typename iRngT::realmtxdef_t realmtxdef_t;
realmtxdef_t trX(tr_cnt, xwidth, true), trY(tr_cnt, 1), tX(2, xwidth, true), tY(2, 1);
rng::distr_normal_naive<iRngT> rg(iR, real_t(0), real_t(1));
rg.gen_matrix_no_bias(trX); rg.gen_matrix_no_bias(tX);
iR.binary_matrix(trY), iR.binary_matrix(tY);
ASSERT_TRUE(td.absorb(::std::move(trX), ::std::move(trY), ::std::move(tX), ::std::move(tY)));
}
//template<ADCorr corrType, typename RealT>
template<typename RealT>
void test_selu_distr(const size_t seedVal, const RealT dpa, const neurons_count_t xwidth = 10, const neurons_count_t nc = 30
, const bool bApplyWeightNorm = false, const bool bVerbose = true
, const vec_len_t batchSize = 1000, const vec_len_t batchesCnt = 100)noexcept
{
typedef RealT real_t;
constexpr unsigned _scopeMsgLen = 128;
char _scopeMsg[_scopeMsgLen];
sprintf_s(_scopeMsg, "SELU_Distribution for X=%d/nc=%d with dropout dpa=%04.3f", xwidth, nc, dpa);
SCOPED_TRACE(_scopeMsg);
STDCOUTL(_scopeMsg);
const real_t learningRate(::std::numeric_limits<real_t>::min());
struct myIntf : public d_int_nI<real_t> {
typedef inspector_act_var_checker<real_t, true> iInspect_t;
};
typedef grad_works_f<myIntf
, GW::ILR_dummy
, GW::Loss_Addendums_dummy
> GrW;
//typedef activation::selu<real_t, 0, 0, 0, 1000000, corrType> mySelu_t;
typedef activation::selu<real_t, 0, 0, 0, 1000000> mySelu_t;
layer_input<myIntf> inp(xwidth);
LFC_DO<mySelu_t, GrW> fcl(nc, learningRate);
fcl.dropoutPercentActive(dpa);
#ifndef TESTS_SKIP_LONGRUNNING
LFC_DO<mySelu_t, GrW> fcl2(nc, learningRate);
fcl2.dropoutPercentActive(dpa);
LFC_DO<mySelu_t, GrW> fcl3(nc, learningRate);
fcl3.dropoutPercentActive(dpa);
LFC_DO<mySelu_t, GrW> fcl4(nc, learningRate);
fcl4.dropoutPercentActive(dpa);
#endif
layer_output<activation::softsigm_quad_loss<real_t>, GrW> outp(1, learningRate);
#ifdef TESTS_SKIP_LONGRUNNING
auto lp = make_layers(inp, fcl, outp);
#else
auto lp = make_layers(inp, fcl, fcl2, fcl3, fcl4, outp);
#endif
nnet_train_opts<real_t, training_observer_stdcout<real_t, eval_classification_binary_cached<real_t>>> opts(1);
opts.batchSize(batchSize);
auto nn = make_nnet(lp);
nn.get_iRng().seed64(seedVal);
inmem_train_data<real_t> td;
_test_selu_make_td(td, batchesCnt*batchSize, xwidth, nn.get_iRng());
if (bApplyWeightNorm) {
typedef weights_init::procedural::LSUVExt<decltype(nn), ::std::decay_t<decltype(td)>> winit_t;
winit_t::LayerSetts_t def, outpS;
def.bOverPreActivations = false;
def.bCentralNormalize = true;
def.bScaleNormalize = true;
def.bOnInvidualNeurons = true;
def.maxTries = 10;
def.targetScale = real_t(1.);
def.bVerbose = bVerbose;
outpS.bCentralNormalize = false;
outpS.bScaleNormalize = false;
outpS.bVerbose = bVerbose;
winit_t obj(nn, td, def);
obj.setts().add(outp.get_layer_idx(), outpS);
//individual neuron stats requires a lot of data to be correctly evaluated
if (!obj.run()) {
STDCOUTL("*** Layer with ID=" << obj.m_firstFailedLayerIdx << " was the first to fail convergence. There might be more of them.");
}
}
nn.get_iRng().seed64(seedVal + 1);
auto ec = nn.train(td, opts);
ASSERT_EQ(decltype(nn)::ErrorCode::Success, ec) << "Error code description: " << nn.get_last_error_string();
ASSERT_NO_FATAL_FAILURE(nn.get_iInspect().report_stats(bVerbose));
}
TEST(TestSelu, SELU_Distribution) {
typedef float real_t;
//#TODO
STDCOUTL("#The test may generate some false failures b/c of data variance. Need to redesign it.");
const size_t t = ::std::time(0);
const real_t dpa = real_t(.8);
STDCOUTL("================ No weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, real_t(1.), 10, 50, false));
STDCOUTL("================ With weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, real_t(1.), 10, 50, true));
STDCOUTL("================ No weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, dpa, 10, 50, false));
STDCOUTL("================ With weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, dpa, 10, 50, true));
#ifndef TESTS_SKIP_LONGRUNNING
STDCOUTL("================ No weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, real_t(1.), 100, 400, false));
STDCOUTL("================ With weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, real_t(1.), 100, 400, true));
STDCOUTL("================ No weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, dpa, 100, 400, false));
STDCOUTL("================ With weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr(t, dpa, 100, 400, true));
#endif
/*STDCOUTL("================ No weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, real_t(1.), 10, 50, false));
STDCOUTL("================ With weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, real_t(1.), 10, 50, true));
STDCOUTL("================ No weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, dpa, 10, 50, false));
STDCOUTL("================ With weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, dpa, 10, 50, true));
#ifndef TESTS_SKIP_LONGRUNNING
STDCOUTL("================ No weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, real_t(1.), 100, 400, false));
STDCOUTL("================ With weight renormalizing ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, real_t(1.), 100, 400, true));
STDCOUTL("================ No weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, dpa, 100, 400, false));
STDCOUTL("================ With weight renormalizing + AlphaDropout ================");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::no>(t, dpa, 100, 400, true));
STDCOUTL("Assessing corrections (without weight renormalizing)");
STDCOUTL("ADCorr::correctVar");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::correctVar>(t, dpa, 100, 400, false));
STDCOUTL("ADCorr::correctDoVal");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::correctDoVal>(t, dpa, 100, 400, false));
STDCOUTL("ADCorr::correctDoAndVar");
ASSERT_NO_FATAL_FAILURE(test_selu_distr<ADCorr::correctDoAndVar>(t, dpa, 100, 400, false));
#endif*/
}
/*
TEST(TestSelu, AlphaDropoutDistributionWithCorrection) {
typedef float real_t;
const size_t t = ::std::time(0);
vec_len_t xW = 20;
for (neurons_count_t nc = 5; nc <= 30; nc+=5) {
real_t dpa = real_t(0.97);
STDCOUTL(::std::endl<<"================ No correction ================");
ASSERT_NO_FATAL_FAILURE((test_selu_distr<real_t, false>(t, dpa, xW, nc, true, false)));
STDCOUTL("================ With correction ================");
ASSERT_NO_FATAL_FAILURE((test_selu_distr<real_t, true>(t, dpa, xW, nc, true, false)));
dpa = real_t(0.7);
STDCOUTL("================ No correction ================");
ASSERT_NO_FATAL_FAILURE((test_selu_distr<real_t, false>(t, dpa, xW, nc, true, false)));
STDCOUTL("================ With correction ================");
ASSERT_NO_FATAL_FAILURE((test_selu_distr<real_t, true>(t, dpa, xW, nc, true, false)));
}
}*/
| 39.811083
| 145
| 0.690984
|
Arech
|
e7484af3bd1c0655640406fc4a79bdc42ac7ef31
| 756
|
cpp
|
C++
|
src/mbedTLS++/X509Cert.cpp
|
wbrbr/MCServer
|
a7bbca30c560c581127f7b6c49ca427c3e96a1da
|
[
"Apache-2.0"
] | 4,126
|
2015-06-12T21:56:49.000Z
|
2022-03-31T06:33:12.000Z
|
src/mbedTLS++/X509Cert.cpp
|
wbrbr/MCServer
|
a7bbca30c560c581127f7b6c49ca427c3e96a1da
|
[
"Apache-2.0"
] | 2,931
|
2015-06-11T17:13:15.000Z
|
2022-03-31T22:46:31.000Z
|
src/mbedTLS++/X509Cert.cpp
|
wbrbr/MCServer
|
a7bbca30c560c581127f7b6c49ca427c3e96a1da
|
[
"Apache-2.0"
] | 917
|
2015-06-11T21:47:41.000Z
|
2022-03-30T10:32:55.000Z
|
// X509Cert.cpp
// Implements the cX509Cert class representing a wrapper over X509 certs in mbedTLS
#include "Globals.h"
#include "X509Cert.h"
cX509Cert::cX509Cert(void)
{
mbedtls_x509_crt_init(&m_Cert);
}
cX509Cert::~cX509Cert()
{
mbedtls_x509_crt_free(&m_Cert);
}
int cX509Cert::Parse(const void * a_CertContents, size_t a_Size)
{
// mbedTLS requires that PEM-encoded data is passed including the terminating NUL byte,
// and DER-encoded data is decoded properly even with an extra trailing NUL byte, so we simply add one to everything:
AString certContents(static_cast<const char *>(a_CertContents), a_Size);
return mbedtls_x509_crt_parse(&m_Cert, reinterpret_cast<const unsigned char *>(certContents.data()), a_Size + 1);
}
| 18
| 118
| 0.752646
|
wbrbr
|
e74f144bc86d3f5cc1801042f1cdbe5a7e1c4223
| 982
|
cpp
|
C++
|
TLG.cpp
|
absnaik810/SPOJ-Repository
|
ec938a4670491f915432e25490b72a765089ae6c
|
[
"Unlicense"
] | 3
|
2015-06-07T15:53:42.000Z
|
2018-02-20T06:15:10.000Z
|
TLG.cpp
|
harrypotter0/SPOJ
|
3965c5a2c01e47a6cda06f26c26c871a3a1fc028
|
[
"Unlicense"
] | null | null | null |
TLG.cpp
|
harrypotter0/SPOJ
|
3965c5a2c01e47a6cda06f26c26c871a3a1fc028
|
[
"Unlicense"
] | null | null | null |
#include <iostream>
#include <stdlib.h>
using namespace std;
int main()
{
std::ios::sync_with_stdio(false);
int rounds,j=0,k=0;
cin>>rounds;
int player1[rounds];
int player2[rounds];
abc: for(;j<rounds;)
{
cin>>player1[j];
//cout<<"For player 1: "<<player1[j]<<endl;
j++;
break;
}
for(;k<rounds;)
{
cin>>player2[k];
//cout<<"For player 2: "<<player2[k]<<endl;
k++;
//goto abc;
break;
}
if(j<rounds || k<rounds)
{
goto abc;
}
//Make the changes below:
for(j=1; j<rounds; j++)
{
player1[j] = player1[j] + player1[j-1];
}
for(k=1; k<rounds; k++)
{
player2[k] = player2[k] + player2[k-1];
}
int lead[rounds];
for(int i=0; i<rounds; i++)
{
lead[i] = player1[i] - player2[i];
}
int max,value;
max = lead[0];
value = lead[0];
for (int i=0; i<rounds; i++)
{
if(abs(lead[i]) > max){
max = abs(lead[i]);
value = lead[i];
}
}
if(value>0)
cout<<1<<" "<<max<<endl;
else
cout<<2<<" "<<max<<endl;
}
| 14.231884
| 45
| 0.541752
|
absnaik810
|
e757083bcf6dd36e445dfd7c6979d13f34f85cac
| 3,289
|
cpp
|
C++
|
3DLfC4D/source/DisplayTranslator.cpp
|
FMalmberg/3Delight-for-Cinema-4D
|
78e7e81044fed4226c3613f46edb1e80c58247d6
|
[
"MIT"
] | 3
|
2018-10-06T17:05:53.000Z
|
2020-06-29T21:31:11.000Z
|
3DLfC4D/source/DisplayTranslator.cpp
|
FMalmberg/3Delight-for-Cinema-4D
|
78e7e81044fed4226c3613f46edb1e80c58247d6
|
[
"MIT"
] | 28
|
2018-11-14T19:08:18.000Z
|
2019-06-30T10:25:13.000Z
|
3DLfC4D/source/DisplayTranslator.cpp
|
FMalmberg/3Delight-for-Cinema-4D
|
78e7e81044fed4226c3613f46edb1e80c58247d6
|
[
"MIT"
] | 6
|
2018-08-29T11:02:39.000Z
|
2019-05-13T13:35:17.000Z
|
#include "DisplayTranslator.h"
#include "odisplay.h"
#include "DL_Utilities.h"
#include "DL_TypeConversions.h"
#include "c4d.h"
#include "nsi.hpp"
#include <customgui_inexclude.h>
void DisplayTranslator::CreateNSINodes(const char* Handle, const char* ParentTransformHandle, BaseList2D* C4DNode, BaseDocument* doc, DL_SceneParser* parser){
if (parser->GetRenderMode() != FINAL_RENDER){ //Don't output AOVs for preview render
return;
}
NSI::Context ctx(parser->GetContext());
BaseObject* obj=(BaseObject*)C4DNode;
BaseContainer* data=obj->GetDataInstance();
layer_handle = string(Handle) + string("outputlayer");
//layer_handle=string(parser->GetUniqueName("outputlayer"));
ctx.Create(layer_handle, "outputlayer");
string scalarformat="float";
long datatype=data->GetInt32(DEPTH, DEPTH_16);
long drivertype_ID=data->GetInt32(DRIVER);
string drivername="tiff";
if(drivertype_ID==DRIVER_EXR){
drivername="exr";
}
if(drivertype_ID==DRIVER_TIFF){
if(datatype==DEPTH_8){
scalarformat="uint8";
}
else if(datatype==DEPTH_16){
scalarformat="uint16";
}
else if(datatype==DEPTH_32){
scalarformat="float";
}
}
else if(drivertype_ID==DRIVER_EXR){
if(datatype==DEPTH_16){
scalarformat="half";
}
else if(datatype==DEPTH_32){
scalarformat="float";
}
}
ctx.SetAttribute(layer_handle,(
NSI::StringArg("variablename", "Ci"),
NSI::StringArg("layername", "primary"),
NSI::StringArg("layertype", "color"),
NSI::StringArg("variablesource", "shader"),
NSI::StringArg("scalarformat", scalarformat),
NSI::IntegerArg("withalpha",1),
NSI::StringArg("filter", "gaussian")
));
// driver_handle=string(parser->GetUniqueName("outputdriver"));
driver_handle = string(Handle) + string("outputdriver");
String file=data->GetString(FILENAME,"frame"_s);
Filename filepath=data->GetFilename(PATH,"");
filepath=filepath+Filename("/"+file);
string image_filename=StringToStdString(filepath.GetString());
ctx.Create(driver_handle, "outputdriver");
ctx.SetAttribute(driver_handle, (
NSI::StringArg("drivername", drivername),
NSI::StringArg("imagefilename", image_filename)
));
ctx.Connect(driver_handle, "",layer_handle, "outputdrivers");
}
void DisplayTranslator::ConnectNSINodes(const char* Handle, const char* ParentTransformHandle, BaseList2D* C4DNode, BaseDocument* doc,DL_SceneParser* parser){
if (parser->GetRenderMode() != FINAL_RENDER){ //Don't output AOVs for preview render
return;
}
NSI::Context ctx(parser->GetContext());
ctx.Connect(layer_handle, "", "scene_camera_screen", "outputlayers");
//Light sets
BaseObject* obj=(BaseObject*)C4DNode;
BaseContainer* data=obj->GetDataInstance();
InExcludeData* light_list=NULL;
light_list = (InExcludeData*)data->GetCustomDataType(LIGHTS,CUSTOMDATATYPE_INEXCLUDE_LIST);
BaseList2D* light=NULL;
if(light_list){
long nlights=light_list->GetObjectCount();
for(long i=0; i<nlights; i++){
light=NULL;
light=light_list->ObjectFromIndex(doc,i);
if(light){
//Connect light to display
//string light_handle=string(parser->GetAssociatedHandle(light));
//ctx.Connect(light_handle,"",layer_handle,"lightset");
}
}
}
}
| 29.366071
| 159
| 0.704165
|
FMalmberg
|
e75d9a4b97316da4250a8a0c8380bea0f9dba715
| 2,341
|
cpp
|
C++
|
src/imu/imu.cpp
|
tmaltesen/IOsonata
|
3ada9216305653670fccfca8fd53c6597ace8f12
|
[
"MIT"
] | null | null | null |
src/imu/imu.cpp
|
tmaltesen/IOsonata
|
3ada9216305653670fccfca8fd53c6597ace8f12
|
[
"MIT"
] | null | null | null |
src/imu/imu.cpp
|
tmaltesen/IOsonata
|
3ada9216305653670fccfca8fd53c6597ace8f12
|
[
"MIT"
] | null | null | null |
/**-------------------------------------------------------------------------
@file imu.cpp
@brief Implementation of an Inertial Measurement Unit
This a generic abstraction layer for IMU sensor fusion. It is a mean to
provide a common interface to different sensor fusion library out there.
@author Hoang Nguyen Hoan
@date Aug. 1, 2018
@license
Copyright (c) 2018, I-SYST inc., all rights reserved
Permission to use, copy, modify, and distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright
notice and this permission notice appear in all copies, and none of the
names : I-SYST or its contributors may be used to endorse or
promote products derived from this software without specific prior written
permission.
For info or contributing contact : hnhoan at i-syst dot com
THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------*/
#include "imu/imu.h"
/*
bool Imu::Init(const IMU_CFG &Cfg, uint32_t DevAddr, DeviceIntrf * const pIntrf, Timer * const pTimer)
{
SetEvtHandler(Cfg.EvtHandler);
vpTimer = pTimer;
Interface(pIntrf);
DeviceAddess(DevAddr);
return true;
}
*/
bool Imu::Init(const IMU_CFG &Cfg, AccelSensor * const pAccel, GyroSensor * const pGyro, MagSensor * const pMag)
{
vpAccel = pAccel;
vpGyro = pGyro;
vpMag = pMag;
SetEvtHandler(Cfg.EvtHandler);
return true;
}
IMU_FEATURE Imu::Feature(IMU_FEATURE FeatureBit, bool bEnDis)
{
if (bEnDis == true)
{
// Enable
vActiveFeature |= FeatureBit;
}
else
{
// disable
vActiveFeature &= ~FeatureBit;
}
return vActiveFeature;
}
| 29.632911
| 112
| 0.717642
|
tmaltesen
|
e760465d02d1b604c9b96d129a71fe677636455c
| 2,180
|
cc
|
C++
|
snapshot/ios/memory_snapshot_ios.cc
|
rbxeyl/crashpad
|
95b4e6276836283a91e18382fb258598bd77f8aa
|
[
"Apache-2.0"
] | 575
|
2015-06-18T23:58:20.000Z
|
2022-03-23T09:32:39.000Z
|
snapshot/ios/memory_snapshot_ios.cc
|
rbxeyl/crashpad
|
95b4e6276836283a91e18382fb258598bd77f8aa
|
[
"Apache-2.0"
] | 113
|
2015-05-04T09:58:14.000Z
|
2022-01-31T19:35:03.000Z
|
snapshot/ios/memory_snapshot_ios.cc
|
rbxeyl/crashpad
|
95b4e6276836283a91e18382fb258598bd77f8aa
|
[
"Apache-2.0"
] | 52
|
2015-07-14T10:40:50.000Z
|
2022-03-15T01:11:49.000Z
|
// Copyright 2020 The Crashpad 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 "snapshot/ios/memory_snapshot_ios.h"
namespace crashpad {
namespace internal {
void MemorySnapshotIOS::Initialize(vm_address_t address, vm_size_t size) {
INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
address_ = address;
size_ = base::checked_cast<size_t>(size);
// TODO(justincohen): This is temporary, as MemorySnapshotIOS will likely be
// able to point directly to the deserialized data dump rather than copying
// data around.
buffer_ = std::unique_ptr<uint8_t[]>(new uint8_t[size_]);
memcpy(buffer_.get(), reinterpret_cast<void*>(address_), size_);
INITIALIZATION_STATE_SET_VALID(initialized_);
}
uint64_t MemorySnapshotIOS::Address() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return address_;
}
size_t MemorySnapshotIOS::Size() const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
return size_;
}
bool MemorySnapshotIOS::Read(Delegate* delegate) const {
INITIALIZATION_STATE_DCHECK_VALID(initialized_);
if (size_ == 0) {
return delegate->MemorySnapshotDelegateRead(nullptr, size_);
}
return delegate->MemorySnapshotDelegateRead(buffer_.get(), size_);
}
const MemorySnapshot* MemorySnapshotIOS::MergeWithOtherSnapshot(
const MemorySnapshot* other) const {
CheckedRange<uint64_t, size_t> merged(0, 0);
if (!LoggingDetermineMergedRange(this, other, &merged))
return nullptr;
auto result = std::make_unique<MemorySnapshotIOS>();
result->Initialize(merged.base(), merged.size());
return result.release();
}
} // namespace internal
} // namespace crashpad
| 33.030303
| 78
| 0.760092
|
rbxeyl
|
e764037cd2d2b44a760465b8b68a2aef1705c258
| 334
|
cpp
|
C++
|
impuestoVehicular/src/Moto.cpp
|
Kamjue/Tricode
|
430ce79a4b3cbd198bf32f1fbe90dd4947507d4d
|
[
"MIT"
] | null | null | null |
impuestoVehicular/src/Moto.cpp
|
Kamjue/Tricode
|
430ce79a4b3cbd198bf32f1fbe90dd4947507d4d
|
[
"MIT"
] | 1
|
2018-05-05T04:41:35.000Z
|
2018-05-05T04:51:31.000Z
|
impuestoVehicular/src/Moto.cpp
|
Kamjue/Tricode
|
430ce79a4b3cbd198bf32f1fbe90dd4947507d4d
|
[
"MIT"
] | null | null | null |
#include <Moto.h>
Moto::Moto(){
motorCC = 0;
tasa = 2;
}
Moto::Moto(float cc){
motorCC = cc;
}
Moto::Moto(Moto &m){
motorCC = m.getMotorCC();
}
Moto::~Moto(){}
void Moto::setMotorCC(float cc){
motorCC = cc;
}
float Moto::getMotorCC(){
return motorCC;
}
float Moto::calcularMontoExtra(){
return tasa * getMotorCC();
}
| 12.846154
| 33
| 0.625749
|
Kamjue
|
e7650657d0b9f21048651a2be989ca9c116e6950
| 527
|
cpp
|
C++
|
src/openpose/wrapper/wrapperStructVnect.cpp
|
mooktj/openpose
|
f4ee9cba3621093bba88bb17d1ea6a19ff3236ad
|
[
"DOC"
] | null | null | null |
src/openpose/wrapper/wrapperStructVnect.cpp
|
mooktj/openpose
|
f4ee9cba3621093bba88bb17d1ea6a19ff3236ad
|
[
"DOC"
] | null | null | null |
src/openpose/wrapper/wrapperStructVnect.cpp
|
mooktj/openpose
|
f4ee9cba3621093bba88bb17d1ea6a19ff3236ad
|
[
"DOC"
] | null | null | null |
#include <openpose/wrapper/wrapperStructVnect.hpp>
#include <iostream>
namespace op
{
WrapperStructVnect::WrapperStructVnect(
const bool vnectEnable_, const std::string& modelFolder_,
const std::string& protoTxtFile_, const std::string& trainedModelFile_) :
vnectEnable{vnectEnable_},
modelFolder{modelFolder_},
protoTxtFile{protoTxtFile_},
trainedModelFile{trainedModelFile_}
{
std::cout << "wrapperStructVnect:: WrapperStructVnect(...) constructor\n";
}
}
| 31
| 82
| 0.70019
|
mooktj
|
e7699a65fcbdc716b64dfadd1bb2b3f0f47335ad
| 9,567
|
cpp
|
C++
|
daito-manabe-01/src/ofApp.cpp
|
eaviles/sfpc-2020-rtp
|
ca36258cf126ce668c6688ba88986d88407fe6b6
|
[
"MIT"
] | 5
|
2020-07-12T08:02:28.000Z
|
2021-11-21T17:56:48.000Z
|
daito-manabe-01/src/ofApp.cpp
|
eaviles/sfpc-2020-rtp
|
ca36258cf126ce668c6688ba88986d88407fe6b6
|
[
"MIT"
] | null | null | null |
daito-manabe-01/src/ofApp.cpp
|
eaviles/sfpc-2020-rtp
|
ca36258cf126ce668c6688ba88986d88407fe6b6
|
[
"MIT"
] | 1
|
2021-11-21T17:57:05.000Z
|
2021-11-21T17:57:05.000Z
|
#include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup() {
ofSetWindowShape(IMAGE_WIDTH * 2, IMAGE_HEIGHT * 2);
ofSetFrameRate(60);
ofSetVerticalSync(true);
// grabber.setDeviceID(1);
grabber.setup(IMAGE_WIDTH, IMAGE_HEIGHT);
tracker.setup();
grayImg.allocate(IMAGE_WIDTH, IMAGE_HEIGHT, OF_IMAGE_GRAYSCALE);
diffImg.allocate(IMAGE_WIDTH, IMAGE_HEIGHT, OF_IMAGE_GRAYSCALE);
prevImg.allocate(IMAGE_WIDTH, IMAGE_HEIGHT, OF_IMAGE_GRAYSCALE);
thrsImg.allocate(IMAGE_WIDTH, IMAGE_HEIGHT, OF_IMAGE_GRAYSCALE);
bodyImg.allocate(IMAGE_WIDTH, IMAGE_HEIGHT, OF_IMAGE_COLOR_ALPHA);
palette.push_back(ofColor::magenta);
palette.push_back(ofColor::red);
palette.push_back(ofColor::yellow);
palette.push_back(ofColor::green);
palette.push_back(ofColor::blue);
palette.push_back(ofColor::white);
motionFinder.setMinArea((float)IMAGE_WIDTH * 0.25);
bodyFinder.setMinArea((float)IMAGE_WIDTH * 0.25);
for (int i = 0; i < maxFieldLines; i++) {
fieldLines.push_back(fieldLine());
}
}
//--------------------------------------------------------------
void ofApp::update() {
grabber.update();
if (!grabber.isFrameNew()) return;
tracker.update(grabber);
// Get a greyscale image from the camera.
convertColor(grabber, grayImg, CV_RGB2GRAY);
grayImg.update();
// Get the diff to detect motion.
absdiff(grayImg, prevImg, diffImg);
diffImg.update();
// Threshold the diff image.
thrsImg.setFromPixels(diffImg.getPixels());
threshold(thrsImg, 256 * 0.25);
thrsImg.update();
int numMovPixels = 0;
for (int x = 0; x < IMAGE_WIDTH; x++) {
for (int y = 0; y < IMAGE_HEIGHT; y++) {
numMovPixels += thrsImg.getColor(x, y).r > 127;
}
}
smoothNumMovPixels = 0.95 * smoothNumMovPixels + 0.05 * numMovPixels;
maxFieldLines = ofMap(smoothNumMovPixels, 0, 32000, 512, 12000, true);
// Store the prev image.
prevImg.setFromPixels(grayImg.getPixels());
prevImg.update();
// Find the motion contours.
motionFinder.findContours(thrsImg);
// Convert outlines to shapes.
ofPath p;
for (int i = 0; i < motionFinder.size(); i++) {
auto pl = motionFinder.getPolyline(i).getResampledByCount(12);
for (int j = 0; j < pl.getVertices().size(); j++) {
auto v = pl.getVertices()[j];
float rx = 0; // ofRandom(-4, 4);
float ry = 0; // ofRandom(-4, 4);
if (j == 0) {
p.newSubPath();
p.moveTo(v.x + rx, v.y + ry); //, ofRandom(-12, 12));
} else {
p.lineTo(v.x + rx, v.y + ry); //, ofRandom(-12, 12));
}
}
}
p.close();
p.simplify();
// Maintain a history of motion shapes.
history.push_back(p);
if (history.size() > palette.size()) {
history.erase(history.begin());
}
// Threshold the camera image to get the body.
thrsImg.setFromPixels(grayImg.getPixels());
float bodyThreshold = 256 * 0.65;
threshold(thrsImg, bodyThreshold);
invert(thrsImg);
thrsImg.update();
bodyFinder.findContours(thrsImg);
auto pxls = grayImg.getPixels();
for (int x = 0; x < IMAGE_WIDTH; x++) {
for (int y = 0; y < IMAGE_HEIGHT; y++) {
auto c = pxls.getColor(x, y);
auto d = ofColor(0, 0, 0, c.r < bodyThreshold ? 255 : 0);
bodyImg.setColor(x, y, d);
}
}
bodyImg.update();
}
//------------------------------------------------------------------------------
void ofApp::drawBackground() {
while (fieldLines.size() > maxFieldLines) {
fieldLines.erase(fieldLines.end() - 1);
}
while (fieldLines.size() < maxFieldLines) {
fieldLines.push_back(fieldLine());
}
for (int i = 0; i < fieldLines.size(); i++) {
fieldLine l = fieldLines[i];
if (l.z - l.l > -FIELD_LINES_DEPTH) {
ofSetLineWidth(l.w);
ofDrawLine(l.x, l.y, l.z, l.x, l.y, l.z - l.l);
fieldLines[i].z = l.z - FIELD_LINES_SPEED;
} else {
fieldLines[i] = fieldLine();
}
}
}
//------------------------------------------------------------------------------
void ofApp::drawMotion() {
for (int i = 0; i < history.size(); i++) {
history[i].setColor(palette[i]);
history[i].draw();
}
}
//------------------------------------------------------------------------------
void ofApp::drawBody() {
if (bodyFinder.size() == 0) return;
for (int i = 0; i < bodyFinder.size(); i++) {
auto d = bodyFinder.getPolyline(i).getResampledBySpacing(24);
ofSetColor(ofColor::white);
ofSetLineWidth(12);
d.draw();
vector<ofPoint> pts;
for (int j = 0; j < d.size(); j++) {
pts.push_back(d[j]);
}
ofRandomize(pts);
for (int j = 1; j < pts.size(); j++) {
ofPoint p1 = pts[j - 1];
ofPoint p2 = pts[j];
auto d = (p1 - p2).length();
if (d > 160) continue;
ofSetLineWidth(ofRandomuf() > 0.75 ? 8 : 2);
ofDrawLine(p1, p2);
}
}
}
//------------------------------------------------------------------------------
void ofApp::drawFace() {
for (auto instance : tracker.getInstances()) {
auto lmks = instance.getLandmarks();
ofNoFill();
ofSetColor(ofColor::white);
ofSetLineWidth(8);
lmks.getImageFeature(ofxFaceTracker2Landmarks::JAW).draw();
auto leftEyebrowPoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::LEFT_EYEBROW)
.getResampledByCount(4);
auto rightEyebrowPoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::RIGHT_EYEBROW)
.getResampledByCount(4);
auto leftEyePoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::LEFT_EYE);
auto rightEyePoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::RIGHT_EYE);
auto nosePoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::NOSE_BASE);
auto outerMouthPoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::OUTER_MOUTH)
.getResampledByCount(7);
auto innerMouthPoly =
lmks.getImageFeature(ofxFaceTracker2Landmarks::INNER_MOUTH)
.getResampledByCount(7);
ofSetLineWidth(8);
leftEyebrowPoly.draw();
rightEyebrowPoly.draw();
nosePoly.draw();
ofFill();
ofSetColor(ofColor::white);
ofSetLineWidth(2);
ofPath leftEyePath;
for (int i = 0; i < leftEyePoly.size(); i++) {
if (i == 0) {
leftEyePath.moveTo(leftEyePoly[i]);
} else {
leftEyePath.lineTo(leftEyePoly[i]);
}
}
leftEyePath.draw();
ofPath rightEyePath;
for (int i = 0; i < rightEyePoly.size(); i++) {
if (i == 0) {
rightEyePath.moveTo(rightEyePoly[i]);
} else {
rightEyePath.lineTo(rightEyePoly[i]);
}
}
rightEyePath.draw();
ofDrawLine(leftEyePoly[3], rightEyePoly[0]);
ofDrawLine(leftEyebrowPoly[3], rightEyebrowPoly[0]);
for (int i = 0; i < 4; i++) {
ofDrawLine(leftEyePoly[i], leftEyebrowPoly[i]);
ofDrawLine(rightEyePoly[i], rightEyebrowPoly[i]);
}
ofDrawLine(nosePoly[0], outerMouthPoly[1]);
ofDrawLine(nosePoly[2], outerMouthPoly[1]);
ofDrawLine(nosePoly[2], outerMouthPoly[2]);
ofDrawLine(nosePoly[4], outerMouthPoly[2]);
outerMouthPoly.draw();
ofPath mouthPath;
for (int i = 0; i < innerMouthPoly.size(); i++) {
if (i == 0) {
mouthPath.moveTo(innerMouthPoly[i]);
} else {
mouthPath.lineTo(innerMouthPoly[i]);
}
}
mouthPath.draw();
}
}
//--------------------------------------------------------------
void ofApp::draw() {
ofBackground(ofColor::black);
ofSetColor(ofColor::white);
ofScale(2.0);
drawBackground();
drawMotion();
bodyImg.draw(0, 0);
drawBody();
drawFace();
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key) {}
//--------------------------------------------------------------
void ofApp::keyReleased(int key) {}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y) {}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button) {}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button) {}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button) {}
//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y) {}
//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y) {}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h) {}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg) {}
//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo) {}
| 31.996656
| 80
| 0.503711
|
eaviles
|
e769d813b5c51759681e90356c3301b0d2c7685b
| 4,979
|
cc
|
C++
|
src/google_cloud_debugger/google_cloud_debugger_lib/breakpoint_location_collection.cc
|
emzeq/google-cloud-dotnet-debugger
|
8eafe29b40582ebf735186b574af4d544158033e
|
[
"Apache-2.0"
] | 12
|
2018-06-05T04:06:26.000Z
|
2021-10-09T14:14:18.000Z
|
src/google_cloud_debugger/google_cloud_debugger_lib/breakpoint_location_collection.cc
|
emzeq/google-cloud-dotnet-debugger
|
8eafe29b40582ebf735186b574af4d544158033e
|
[
"Apache-2.0"
] | 47
|
2018-06-01T20:26:22.000Z
|
2021-03-20T14:26:21.000Z
|
src/google_cloud_debugger/google_cloud_debugger_lib/breakpoint_location_collection.cc
|
emzeq/google-cloud-dotnet-debugger
|
8eafe29b40582ebf735186b574af4d544158033e
|
[
"Apache-2.0"
] | 14
|
2018-06-04T17:12:25.000Z
|
2021-10-09T14:14:04.000Z
|
// Copyright 2017 Google Inc. 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 "breakpoint_location_collection.h"
using std::cerr;
namespace google_cloud_debugger {
std::vector<std::shared_ptr<DbgBreakpoint>>
BreakpointLocationCollection::GetBreakpoints() {
std::lock_guard<std::mutex> lock(mutex_);
std::vector<std::shared_ptr<DbgBreakpoint>> return_val = breakpoints_;
return return_val;
}
HRESULT BreakpointLocationCollection::AddFirstBreakpoint(
std::shared_ptr<DbgBreakpoint> breakpoint) {
// Initializes the cache.
il_offset_ = breakpoint->GetILOffset();
method_def_ = breakpoint->GetMethodDef();
method_token_ = breakpoint->GetMethodToken();
method_name_ = breakpoint->GetMethodName();
location_string_ = breakpoint->GetBreakpointLocation();
HRESULT hr = breakpoint->GetCorDebugBreakpoint(&debug_breakpoint_);
if (FAILED(hr)) {
return hr;
}
breakpoints_.push_back(std::move(breakpoint));
return S_OK;
}
HRESULT BreakpointLocationCollection::UpdateBreakpoints(
const DbgBreakpoint &breakpoint) {
HRESULT hr = UpdateExistingBreakpoint(breakpoint);
if (FAILED(hr)) {
cerr << "Failed to activate breakpoint.";
return hr;
}
if (hr == S_OK) {
return hr;
}
// If the breakpoint is not an existing breakpoint and
// it is not even activated, we don't need to do anything.
if (!breakpoint.Activated()) {
return S_OK;
}
std::shared_ptr<DbgBreakpoint> new_breakpoint;
// Creates a new breakpoint from cached information.
new_breakpoint =
std::shared_ptr<DbgBreakpoint>(new (std::nothrow) DbgBreakpoint);
if (!new_breakpoint) {
return E_OUTOFMEMORY;
}
new_breakpoint->Initialize(breakpoint);
new_breakpoint->SetActivated(breakpoint.Activated());
new_breakpoint->SetKillServer(breakpoint.GetKillServer());
// Now sets breakpoint information from the cache.
new_breakpoint->SetILOffset(il_offset_);
new_breakpoint->SetMethodDef(method_def_);
new_breakpoint->SetMethodToken(method_token_);
new_breakpoint->SetMethodName(method_name_);
new_breakpoint->SetCorDebugBreakpoint(debug_breakpoint_);
hr = ActivateCorDebugBreakpointHelper(breakpoint.Activated());
if (FAILED(hr)) {
return hr;
}
{
std::lock_guard<std::mutex> lock(mutex_);
breakpoints_.push_back(std::move(new_breakpoint));
}
return hr;
}
HRESULT BreakpointLocationCollection::UpdateExistingBreakpoint(
const DbgBreakpoint &breakpoint) {
std::lock_guard<std::mutex> lock(mutex_);
const auto &existing_breakpoint = std::find_if(
breakpoints_.begin(), breakpoints_.end(),
[&](std::shared_ptr<DbgBreakpoint> &existing_bp) {
return existing_bp->GetId().compare(breakpoint.GetId()) == 0;
});
if (existing_breakpoint == breakpoints_.end()) {
return S_FALSE;
}
HRESULT hr = ActivateCorDebugBreakpointHelper(breakpoint.Activated());
if (FAILED(hr)) {
return hr;
}
// Remove deactivated breakpoint.
if (!breakpoint.Activated()) {
breakpoints_.erase(existing_breakpoint);
}
return hr;
}
HRESULT BreakpointLocationCollection::ActivateCorDebugBreakpointHelper(
BOOL activation_state) {
if (!debug_breakpoint_) {
std::cerr << "Cannot activate breakpoints without ICorDebugBreakpoint.";
return E_INVALIDARG;
}
BOOL current_activation_state;
HRESULT hr = debug_breakpoint_->IsActive(¤t_activation_state);
if (FAILED(hr)) {
std::cerr << "Failed to check whether breakpoint at " << location_string_
<< " is active or not.";
return hr;
}
if (current_activation_state != activation_state) {
// Clean up case for breakpoint deactivation:
// If none of the breakpoints at this location are active, deactivate the
// ICorDebugBreakpoint.
if (!activation_state) {
const auto &existing_active_breakpoint =
std::find_if(breakpoints_.begin(), breakpoints_.end(),
[&](std::shared_ptr<DbgBreakpoint> &existing_bp) {
return existing_bp->Activated();
});
if (existing_active_breakpoint != breakpoints_.end()) {
return S_OK;
}
// Otherwise, deactivate the breakpoints.
}
hr = debug_breakpoint_->Activate(activation_state);
if (FAILED(hr)) {
std::cerr << "Failed to activate breakpoint at " << location_string_;
return hr;
}
}
return S_OK;
}
} // namespace google_cloud_debugger
| 30.359756
| 77
| 0.709982
|
emzeq
|
e770b1b430223a781c8d895aa0861d711ebb383d
| 898
|
cpp
|
C++
|
src/127.word_ladder/code2.cpp
|
cloudzfy/leetcode
|
9d32090429ef297e1f62877382bff582d247266a
|
[
"MIT"
] | 1
|
2016-07-02T17:44:10.000Z
|
2016-07-02T17:44:10.000Z
|
src/127.word_ladder/code2.cpp
|
cloudzfy/leetcode
|
9d32090429ef297e1f62877382bff582d247266a
|
[
"MIT"
] | null | null | null |
src/127.word_ladder/code2.cpp
|
cloudzfy/leetcode
|
9d32090429ef297e1f62877382bff582d247266a
|
[
"MIT"
] | 1
|
2019-12-21T04:57:15.000Z
|
2019-12-21T04:57:15.000Z
|
class Solution {
public:
int ladderLength(string beginWord, string endWord, unordered_set<string>& wordList) {
queue<pair<string, int> > q;
q.push(make_pair(beginWord, 1));
wordList.erase(beginWord);
while (!q.empty()) {
string u = q.front().first;
int len = q.front().second;
q.pop();
for (int i = 0; i < u.length(); i++) {
for (int j = 0; j < 26; j++) {
if (u[i] == 'a' + j) continue;
string tmp = u;
tmp[i] = 'a' + j;
if (wordList.find(tmp) != wordList.end()) {
if (tmp == endWord) return len + 1;
q.push(make_pair(tmp, len + 1));
wordList.erase(tmp);
}
}
}
}
return 0;
}
};
| 33.259259
| 89
| 0.398664
|
cloudzfy
|
e773122ab12d5e4f909382d14ac428b88265be8a
| 1,071
|
cpp
|
C++
|
src/grid_service/src/MappedCell.cpp
|
phildkim/Swarmathon-PCC
|
20cae8db6e58f696b83eb4ce71a7cb8913bde1aa
|
[
"MIT"
] | null | null | null |
src/grid_service/src/MappedCell.cpp
|
phildkim/Swarmathon-PCC
|
20cae8db6e58f696b83eb4ce71a7cb8913bde1aa
|
[
"MIT"
] | null | null | null |
src/grid_service/src/MappedCell.cpp
|
phildkim/Swarmathon-PCC
|
20cae8db6e58f696b83eb4ce71a7cb8913bde1aa
|
[
"MIT"
] | null | null | null |
#include <cmath>
#include <sys/types.h>
#include <sys/mman.h>
#include <new>
#include <unistd.h>
#include "MappedCell.h"
// Static Class Variables
const uint8_t MappedCell::STATUS_REGISTER_OFFSET = 0;
const uint8_t MappedCell::STATISTIC_REGISTER_OFFSET = 4;
// Public Member Functions
MappedCell::MappedCell(uint8_t * addr) :
cell_base_addr(addr){}
MappedCell::~MappedCell() {}
uint8_t * const MappedCell::getCellAddress() {
return this->cell_base_addr;
}
float MappedCell::getCellStatistic(uint8_t stride) const {
return *(((float *) (this->cell_base_addr + MappedCell::STATISTIC_REGISTER_OFFSET)) + stride);
}
void MappedCell::setCellStatistic(uint8_t stride, float data) {
*(((float *) (this->cell_base_addr + MappedCell::STATISTIC_REGISTER_OFFSET)) + stride) = data;
}
uint8_t MappedCell::getCellStatus(uint8_t stride) const {
return *(this->cell_base_addr + MappedCell::STATUS_REGISTER_OFFSET + stride);
}
void MappedCell::setCellStatus(uint8_t stride, uint8_t data) {
*(this->cell_base_addr + MappedCell::STATUS_REGISTER_OFFSET + stride) ^= data;
}
| 28.945946
| 95
| 0.754435
|
phildkim
|
e7754e57ce66ff347cb643c30aae7259efb503fd
| 8,577
|
cpp
|
C++
|
Source/SpaceTarget/Private/ARCoreSlamGenerator.cpp
|
zhmxiaowo/SpaceTarget
|
32649a9eef3e6a1806cde7589f5065b17d3e72ab
|
[
"MIT"
] | 1
|
2021-12-13T12:43:03.000Z
|
2021-12-13T12:43:03.000Z
|
Source/SpaceTarget/Private/ARCoreSlamGenerator.cpp
|
zhmxiaowo/SpaceTarget
|
32649a9eef3e6a1806cde7589f5065b17d3e72ab
|
[
"MIT"
] | null | null | null |
Source/SpaceTarget/Private/ARCoreSlamGenerator.cpp
|
zhmxiaowo/SpaceTarget
|
32649a9eef3e6a1806cde7589f5065b17d3e72ab
|
[
"MIT"
] | 1
|
2022-03-02T08:51:59.000Z
|
2022-03-02T08:51:59.000Z
|
#include "ARCoreSlamGenerator.h"
#if PLATFORM_ANDROID
#include "Runtime/Launch/Public/Android/AndroidJNI.h"
#include "Runtime/ApplicationCore/Public/Android/AndroidApplication.h"
#include "GoogleARCoreCameraImage.h"
#include "GoogleARCoreTypes.h"
#include "GoogleARCoreFunctionLibrary.h"
#include "GoogleARCoreCameraIntrinsics.h"
#endif
#include <ARBlueprintLibrary.h>
#include "SpaceTargetModule.h"
AARCoreSlamGenerator::AARCoreSlamGenerator()
{
isInitIntrinsics = false;
}
void AARCoreSlamGenerator::BeginPlay()
{
Super::BeginPlay();
UE_LOG(LogSpaceTarget, Log, TEXT("ARCoreSlamGenerator has been created!"));
}
void AARCoreSlamGenerator::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
}
//#include <Engine/World.h>
bool AARCoreSlamGenerator::GetCameraIntrinsics(FCameraIntrisics& ci)
{
bool result = false;
//调用太频繁直接崩溃了,测试后发现参数都是一样的,所以缓存起来
if(!isInitIntrinsics)
{
#if PLATFORM_ANDROID
UGoogleARCoreCameraIntrinsics* cameraintrinsics = nullptr;
EGoogleARCoreFunctionStatus google_intrinsics_status = UGoogleARCoreFrameFunctionLibrary::GetCameraImageIntrinsics(cameraintrinsics);
if (google_intrinsics_status == EGoogleARCoreFunctionStatus::Success)
{
int32 r1,r2;
cameraintrinsics->GetImageDimensions(r1, r2);
if(r1 != 0 && r2 != 0)
{
_intrisics.resolution.X = r1; _intrisics.resolution.Y = r2;
cameraintrinsics->GetFocalLength(_intrisics.focal.X, _intrisics.focal.Y);
cameraintrinsics->GetPrincipalPoint(_intrisics.pricipal.X, _intrisics.pricipal.Y);
//UE_LOG(LogSpaceTarget,Log,TEXT("_intrisics : %s"),*(_intrisics.resolution.ToString()));
UE_LOG(LogSpaceTarget, Log, TEXT("resolution : %s focal: %s pricipal: %s"), *(_intrisics.resolution.ToString()), *(_intrisics.focal.ToString()), *(_intrisics.pricipal.ToString()));
ci = _intrisics;
isInitIntrinsics = true;
result = true;
}
}
else
{
result = false;
}
#endif
}
else
{
ci = _intrisics;
result = true;
}
return result;
}
bool AARCoreSlamGenerator::GetCameraPose(FCameraPose& cp)
{
bool result = false;
UWorld* world = this->GetWorld();
if(world)
{
APlayerCameraManager* camManager = world->GetFirstPlayerController()->PlayerCameraManager;
if(camManager)
{
FVector cam_pos = camManager->GetCameraLocation();
FQuat cam_qua = camManager->GetCameraRotation().Quaternion();
//UE_LOG(LogSpaceTarget, Log, TEXT("cam_pos : %s cam_qua : %s"), *(cam_pos.ToString()), *(cam_qua.ToString()));
//unreal will change it automaticly.but we need the real rotation relative to camera image.
switch (FPlatformMisc::GetDeviceOrientation())
{
case EDeviceScreenOrientation::Portrait:
break;
case EDeviceScreenOrientation::LandscapeLeft:
cam_qua = cam_qua * FRotator(0, 0, -90).Quaternion();
break;
case EDeviceScreenOrientation::LandscapeRight:
cam_qua = cam_qua * FRotator(0, 0, 90).Quaternion();
break;
case EDeviceScreenOrientation::PortraitUpsideDown:
cam_qua = cam_qua * FRotator(0, 0, 180).Quaternion();//need test.
break;
default:
break;
}
cp.position = cam_pos;
cp.rotation = cam_qua;
if(cp.position.ContainsNaN())
{
result = false;
}else
{
result = true;
}
}
}
return result;
}
void AARCoreSlamGenerator::SetCameraPose(FTransform cp)
{
//TODO:存在问题,需要改
UWorld* world = this->GetWorld();
if (world)
{
APlayerCameraManager* camManager = world->GetFirstPlayerController()->PlayerCameraManager;
if (camManager)
{
FVector InCamera_v = camManager->GetCameraLocation();
FRotator InCamera_r = camManager->GetCameraRotation();
FVector v = cp.GetLocation();
FRotator r = cp.GetRotation().Rotator();
FVector CorrectVector = FRotator(0, InCamera_r.Yaw - r.Yaw, 0).RotateVector(v);
FVector camera_v = InCamera_v + v;
FRotator camera_r = InCamera_r + r;
UARBlueprintLibrary::SetARWorldOriginLocationAndRotation(InCamera_v - CorrectVector, FRotator(0, InCamera_r.Yaw - r.Yaw, 0), true, true);
//FTransform alignTransform = UARBlueprintLibrary::GetAlignmentTransform();
//FTransform orignal = cp * camManager->GetActorTransform();
//orignal = alignTransform * orignal;
//FRotator rotator = orignal.Rotator();
//rotator.Pitch = 0;
//rotator.Roll = 0;
//orignal.SetRotation(rotator.Quaternion());
//UARBlueprintLibrary::SetAlignmentTransform(orignal);
//UARBlueprintLibrary::SetARWorldOriginLocationAndRotation(orignal.GetLocation(), orignal.Rotator(), true, true);
}
}
//UARBlueprintLibrary::SetARWorldOriginLocationAndRotation(cp.GetLocation(), cp.Rotator(), true, true);
}
bool AARCoreSlamGenerator::GetTrackingStatus(FXRTrackingState& ts)
{
bool result = false;
if (UARBlueprintLibrary::GetARSessionStatus().Status == EARSessionStatus::Running)
{
EARTrackingQuality currTrackingQuality = UARBlueprintLibrary::GetTrackingQuality();
switch (currTrackingQuality)
{
case EARTrackingQuality::NotTracking:
ts = FXRTrackingState::Lost;
break;
case EARTrackingQuality::OrientationAndPosition:
ts = FXRTrackingState::Tracking;
break;
case EARTrackingQuality::OrientationOnly:
ts = FXRTrackingState::TrackingUnStable;
break;
default:
ts = FXRTrackingState::Lost;
break;
}
result = true;
}
else
{
ts = FXRTrackingState::None;
}
return result;
}
bool AARCoreSlamGenerator::GetCameraTexture(FCameraTexture& ct)
{
bool result = false;
if (UARBlueprintLibrary::GetARSessionStatus().Status == EARSessionStatus::Running)
{
#if PLATFORM_ANDROID
UGoogleARCoreCameraImage* cameraimage = nullptr;
EGoogleARCoreFunctionStatus google_image_status = UGoogleARCoreFrameFunctionLibrary::AcquireCameraImage(cameraimage);
if (google_image_status == EGoogleARCoreFunctionStatus::Success)
{
//GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("get camera image success")));
int32 pixelStride = 0;
int32 rowStride = 0;
const uint8* ydata = nullptr;
const uint8* udata = nullptr;
const uint8* vdata = nullptr;
int32 ylen = 0, ulen = 0, vlen = 0;
int32 width = cameraimage->GetWidth();
int32 height = cameraimage->GetHeight();
udata = cameraimage->GetPlaneData(1, pixelStride, rowStride, ulen);
//ArImage_getPlaneData(arsession, cameraimage->ArImage, 1, &udata, ulen);
vdata = cameraimage->GetPlaneData(2, pixelStride, rowStride, vlen);
//ArImage_getPlaneData(cameraimage->SessionHandle,cameraimage->ArImage, 2, &vdata, vlen);
ydata = cameraimage->GetPlaneData(0, pixelStride, rowStride, ylen);
//ArImage_getPlaneData(cameraimage->SessionHandle, cameraimage->ArImage, 0, &ydata, ylen);
if (ylen == 0 || ulen == 0)
{
UE_LOG(LogSpaceTarget, Error , TEXT("yuv data error"));
return result;
}
int mem_len = width * height * 4;
if (ct.data == NULL || ct.length != mem_len)
{
delete(ct.data);
ct.data = new uint8[mem_len];
ct.length = mem_len;
}
//yuv420 to argb
int r, g, b;
uint8* rptr = ct.data;
for (size_t y = 0; y < height; y++)
{
const uint8* Y_rowPtr = ydata + y * rowStride;
const uint8* UV_rowPtr = udata + (y >> 1) * rowStride;
// uint8_t * V_rowPtr = srcVPtr + (y >> 1) * Y_rowStride / 4;
for (size_t x = 0; x < width; x++)
{
uint8_t Y = Y_rowPtr[x];
size_t uIndex = x & 0xfffffffe;
uint8_t U = UV_rowPtr[uIndex];
uint8_t V = UV_rowPtr[uIndex + 1];
double R = ((Y - 16) * 1.164 + (V - 128) * 1.596);
double G = ((Y - 16) * 1.164 - (U - 128) * 0.392 - (V - 128) * 0.813);
double B = ((Y - 16) * 1.164 + (U - 128) * 2.017);
r = FMath::Clamp((int)R, 0, 255);
g = FMath::Clamp((int)G, 0, 255);
b = FMath::Clamp((int)B, 0, 255);
*(rptr++) = 255; // alpha always 255
*(rptr++) = (uint8)r;
*(rptr++) = (uint8)g;
*(rptr++) = (uint8)b;
}
}
ydata = nullptr;
udata = nullptr;
vdata = nullptr;
cameraimage->Release();
//ArImage_release(cameraimage);
//android ndk image direction is left.
ct.direction = FImageDirection::LEFT;
result = true;
}
else
{
//fail to get image ,mostly is the ARCore not avilable.
UEnum* EnumPtr = FindObject<UEnum>(ANY_PACKAGE, TEXT("EGoogleARCoreFunctionStatus"), true);
FString CurShooterDataStr(EnumPtr->GetNameByValue((int)google_image_status).ToString());
UE_LOG(LogSpaceTarget, Error, TEXT("EGoogleARCoreFunctionStatus : %s"), *CurShooterDataStr);
return result;
}
#endif
}
return result;
}
| 30.30742
| 186
| 0.689868
|
zhmxiaowo
|
e776594fbd598c95b3e81560af668d272e915e5b
| 1,119
|
cpp
|
C++
|
nowcoder/contest/33540/L.cpp
|
StableAgOH/solution-codes
|
1fde9424a40f989570e05d7340ddd5497a0d390d
|
[
"CC0-1.0"
] | null | null | null |
nowcoder/contest/33540/L.cpp
|
StableAgOH/solution-codes
|
1fde9424a40f989570e05d7340ddd5497a0d390d
|
[
"CC0-1.0"
] | null | null | null |
nowcoder/contest/33540/L.cpp
|
StableAgOH/solution-codes
|
1fde9424a40f989570e05d7340ddd5497a0d390d
|
[
"CC0-1.0"
] | null | null | null |
#include <iostream>
#include <chrono>
using namespace std;
//==========================================
typedef long long ll;
inline ll s(ll a,ll b) { return a*(a+1)/2*b*(b+1)/2; }
signed main(signed argc, char const *argv[])
{
#ifdef LOCAL
freopen("in.in", "r", stdin);
freopen("out.out", "w", stdout);
auto c1 = chrono::high_resolution_clock::now();
#endif
#ifdef DEBUG
freopen("in.in", "r", stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
//======================================
ll n,m,x,y;
cin>>n>>m>>x>>y;
if(n<m) swap(n,m);
if(x<y) swap(x,y);
ll a,b;
if(n==x) cout<<s(n,m-y)<<endl;
else if(m==x) cout<<s(m,n-y)<<endl;
else if(m==y) cout<<s(m,n-x)<<endl;
else
{
ll res = s(n,m-y)+s(m,n-x)-s(m-y,n-x);
if(m>x) res = max(res, s(n,m-x)+s(m,n-y)-s(m-x,n-y));
cout<<res<<endl;
}
//======================================
#ifdef LOCAL
auto c2 = chrono::high_resolution_clock::now();
cerr<<"Time Used:"<<chrono::duration_cast<chrono::milliseconds>(c2-c1).count()<<"ms"<<endl;
#endif
return 0;
}
| 27.292683
| 95
| 0.495085
|
StableAgOH
|
e77a26c34f01769bc8dc5eff54281cff525c16ea
| 1,235
|
cpp
|
C++
|
BZOJ/4518/code.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
BZOJ/4518/code.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
BZOJ/4518/code.cpp
|
sjj118/OI-Code
|
964ea6e799d14010f305c7e4aee269d860a781f7
|
[
"MIT"
] | null | null | null |
#include<iostream>
#include<cstdio>
#define rep(i,x,y) for(register int i=(x);i<=(y);++i)
#define per(i,x,y) for(register int i=(x);i>=(y);--i)
typedef long long LL;
const int maxn=3010;
using namespace std;
inline LL sqr(LL x){return x*x;}
inline LL read(){LL tmp=0;char c=getchar();while(c<'0'||c>'9')c=getchar();while(c>='0'&&c<='9')tmp=tmp*10+c-'0',c=getchar();return tmp;}
LL n,m;
LL f[maxn][maxn],a[maxn],sum;
int q[maxn],ql,qr;
inline LL y(int p,int i){return f[p][i]+sqr(a[i])*m+2*sum*a[i];}
inline LL x(int i){return 2*m*a[i];}
inline LL trans(int i,int j,int k){return f[i-1][k]+m*sqr(a[j]-a[k])-2*sum*(a[j]-a[k]);}
int main(){
scanf("%lld%lld",&n,&m);
rep(i,1,n)sum+=a[i]=read();
if(m>n){
LL ans=0;
rep(i,1,n)ans+=sqr(a[i])*m-2*sum*a[i];
printf("%lld",ans+sqr(sum));
}else{
rep(i,1,n)a[i]+=a[i-1];
q[ql=qr=1]=0;
rep(i,1,m){
rep(j,1,n){
while(qr>ql&&(double(y(i-1,q[ql+1])-y(i-1,q[ql]))/double(x(q[ql+1])-x(q[ql]))<=a[j]))++ql;
f[i][j]=trans(i,j,q[ql]);
}
q[ql=qr=1]=0;
rep(j,1,n){
while(qr>ql&&double(y(i,j)-y(i,q[qr]))/double(x(j)-x(q[qr]))<=double(y(i,q[qr])-y(i,q[qr-1]))/double(x(q[qr])-x(q[qr-1])))--qr;
q[++qr]=j;
}
}
printf("%lld",f[m][n]+sqr(sum));
}
return 0;
}
| 30.121951
| 136
| 0.551417
|
sjj118
|
e77bd28725cce947d5285e06c0006be2daa9a6e2
| 2,142
|
cc
|
C++
|
src/xqp/qpconfig.cc
|
DouglasRMiles/QuProlog
|
798d86f87fb4372b8918ef582ef2f0fc0181af2d
|
[
"Apache-2.0"
] | 5
|
2019-11-20T02:05:31.000Z
|
2022-01-06T18:59:16.000Z
|
src/xqp/qpconfig.cc
|
logicmoo/QuProlog
|
798d86f87fb4372b8918ef582ef2f0fc0181af2d
|
[
"Apache-2.0"
] | null | null | null |
src/xqp/qpconfig.cc
|
logicmoo/QuProlog
|
798d86f87fb4372b8918ef582ef2f0fc0181af2d
|
[
"Apache-2.0"
] | 2
|
2022-01-08T13:52:24.000Z
|
2022-03-07T17:41:37.000Z
|
/***************************************************************************
qpconfig.cc - configuration
-------------------
begin : April 2004
copyright : (C) 2004 by Peter Robinson
email : pjr@itee.uq.edu.au
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
// $Id: qpconfig.cc,v 1.1 2004/05/09 23:51:08 qp Exp $
#include "qpconfig.h"
#include <iostream>
#include "xqp.h"
using namespace std;
QPConfig::QPConfig(Xqp* xe)
: QSettings(),
parent(xe),
default_font("Lucidatypewriter", 12, QFont::Normal),
default_color(QColor("white"))
{
QString sf = default_font.toString();
QString fontstring = value("/Xqp/font", sf).toString();
font.fromString(fontstring);
QString def_cname = default_color.name();
QString cname = value("/Xqp/color", def_cname).toString();
color = QColor(cname);
x = value("/Xqp/x", 0).toInt();
y = value("/Xqp/y", 0).toInt();
width = value("/Xqp/width", 800).toInt();
height = value("/Xqp/height", 800).toInt();
}
QPConfig::~QPConfig()
{
setValue("/Xqp/font", font.toString());
setValue("/Xqp/color", color.name());
setValue("/Xqp/x",parent-> x());
setValue("/Xqp/y", parent->y());
setValue("/Xqp/width", parent->width());
setValue("/Xqp/height", parent->height());
}
void QPConfig::setQPFont(const QFont& f)
{
font = f;
}
void QPConfig::setQPColor(const QColor& c)
{
color = c;
}
| 33.46875
| 77
| 0.457983
|
DouglasRMiles
|
e77cfd5b99f366a07db61d2aa365c203a381c272
| 1,213
|
cpp
|
C++
|
Plugins/CaptionMod/SourceSDK/scheme.cpp
|
anchurcn/MetaHookSv
|
8408f57d5abb2109285ed9f7897e3a0776e51c87
|
[
"MIT"
] | 31
|
2021-01-20T08:12:48.000Z
|
2022-03-29T16:47:50.000Z
|
Plugins/CaptionMod/SourceSDK/scheme.cpp
|
anchurcn/MetaHookSv
|
8408f57d5abb2109285ed9f7897e3a0776e51c87
|
[
"MIT"
] | 118
|
2021-02-04T17:57:48.000Z
|
2022-03-31T13:03:21.000Z
|
Plugins/CaptionMod/SourceSDK/scheme.cpp
|
anchurcn/MetaHookSv
|
8408f57d5abb2109285ed9f7897e3a0776e51c87
|
[
"MIT"
] | 13
|
2021-01-21T01:43:19.000Z
|
2022-03-15T04:51:19.000Z
|
#include <vgui/IScheme.h>
using namespace vgui;
//-----------------------------------------------------------------------------
// Purpose:
// Input : font -
// Output : char const
//-----------------------------------------------------------------------------
char const *IScheme::GetFontName( const HFont& font )
{
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Reload the fonts in all schemes
//-----------------------------------------------------------------------------
void ISchemeManager::ReloadFonts()
{
}
// first scheme loaded becomes the default scheme, and all subsequent loaded scheme are derivitives of that
HScheme ISchemeManager::LoadSchemeFromFileEx(VPANEL sizingPanel, const char *fileName, const char *tag)
{
return 0;
}
// gets the proportional coordinates for doing screen-size independant panel layouts
// use these for font, image and panel size scaling (they all use the pixel height of the display for scaling)
int ISchemeManager::GetProportionalScaledValueEx( HScheme scheme, int normalizedValue )
{
return 0;
}
int ISchemeManager::GetProportionalNormalizedValueEx( HScheme scheme, int scaledValue )
{
return 0;
}
| 31.921053
| 110
| 0.564716
|
anchurcn
|
e780f72bbebf1dd2ddbdde14ef266bebf9bf5557
| 504
|
cpp
|
C++
|
src/mdlitr2d.cpp
|
degarashi/beat
|
456cc4469067509f0746fbe4eca0d3a0879cb894
|
[
"MIT"
] | null | null | null |
src/mdlitr2d.cpp
|
degarashi/beat
|
456cc4469067509f0746fbe4eca0d3a0879cb894
|
[
"MIT"
] | null | null | null |
src/mdlitr2d.cpp
|
degarashi/beat
|
456cc4469067509f0746fbe4eca0d3a0879cb894
|
[
"MIT"
] | null | null | null |
#include "tfnode_base2d.hpp"
namespace beat {
namespace g2 {
MdlItr::MdlItr(const Tf_SP& sp):
_sp(sp)
{}
MdlItr& MdlItr::operator ++ () {
_sp = _sp->getSibling();
return *this;
}
bool MdlItr::operator == (const MdlItr& m) const {
return _sp == m._sp;
}
bool MdlItr::operator != (const MdlItr& m) const {
return !(operator == (m));
}
MdlItr::operator bool () const {
return static_cast<bool>(_sp);
}
const ITf* MdlItr::get() const {
return _sp.get();
}
}
}
| 19.384615
| 52
| 0.597222
|
degarashi
|
e78114aaae1075dd73c71898b3fe53a8fc32ebec
| 12,461
|
cpp
|
C++
|
amd_openvx_extensions/amd_winml/utilities/MIVisionX-WinML-Validate/source/mivisionx_winml_validate.cpp
|
Indumathi31/MIVisionX
|
e58c8b63d51e3f857d5f1c8750433d1ec887d7f0
|
[
"MIT"
] | null | null | null |
amd_openvx_extensions/amd_winml/utilities/MIVisionX-WinML-Validate/source/mivisionx_winml_validate.cpp
|
Indumathi31/MIVisionX
|
e58c8b63d51e3f857d5f1c8750433d1ec887d7f0
|
[
"MIT"
] | 8
|
2021-12-10T14:07:28.000Z
|
2022-03-04T02:53:11.000Z
|
amd_openvx_extensions/amd_winml/utilities/MIVisionX-WinML-Validate/source/mivisionx_winml_validate.cpp
|
Indumathi31/MIVisionX
|
e58c8b63d51e3f857d5f1c8750433d1ec887d7f0
|
[
"MIT"
] | 2
|
2021-06-01T09:42:51.000Z
|
2021-11-09T14:35:36.000Z
|
/*
Copyright (c) 2019 - 2022 Advanced Micro Devices, Inc. All rights reserved.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "mivisionx_winml_validate.h"
// usage/help function
static void show_usage()
{
printf("\n*************************************************************************************************************************************\n");
printf("\n MIVisionX ONNX Model Validation - %s\n", MIVISIONX_WINML_UTILITY_VERSION);
printf("\n*************************************************************************************************************************************\n");
printf("\n");
printf("Usage:\n\n");
printf("\tMIVisionX-WinML-Validate.exe [options]\t--m <ONNX.model full path>\n");
printf("\t\t\t\t\t\t--i <model input tensor name>\n");
printf("\t\t\t\t\t\t--o <model output tensor name>\n");
printf("\t\t\t\t\t\t--s <output tensor size in (n,c,h,w)>\n");
printf("\t\t\t\t\t\t--l <label.txt full path>\n");
printf("\t\t\t\t\t\t--f <image frame full path>\n");
printf("\t\t\t\t\t\t--d <Learning Model Device Kind <DirectXHighPerformance>> [optional]\n\n");
printf("\n");
printf("\nMIVisionX ONNX Model Validation Parameters\n\n");
printf("\t--m/--model \t\t\t-- onnx model full path [required]\n");
printf("\t--i/--inputName \t\t-- model input tensor name [required]\n");
printf("\t--o/--outputName \t\t-- model output tensor name [required]\n");
printf("\t--s/--outputSize \t\t-- model output tensor size <n,c,h,w> [required]\n");
printf("\t--l/--label \t\t\t-- label.txt file full path [required]\n");
printf("\t--f/--imageFrame \t\t-- imageFrame.png file full path [required]\n");
printf("\t--d/--deviceKind \t\t-- Learning Model Device Kind <0-4> [optional]\n");
for(int i = 0; i < 5; i++)
printf("\t \t\t %d - %s\n",i,deviceNameArray[i]);
printf("\n");
printf("\nMIVisionX ONNX Model Validation Options\n\n");
printf("\t--h/--help\t-- Show full help\n");
printf("\n");
}
// load ONNX model to WinML
void LoadModelFromPath(hstring modelLocation)
{
printf("\n\nMIVisionX: Loading modelfile '%ws' on the '%s' device\n", modelLocation.c_str(), deviceNameArray[deviceIndex].c_str());
int64_t freq = clockFrequency(), t0, t1;
t0 = clockCounter();
model = LearningModel::LoadFromFilePath(modelLocation);
t1 = clockCounter();
printf("MIVisionX: Model file loading took -- %.3f msec\n", (float)(t1 - t0)*1000.0f / (float)freq);
}
// load image file for inference
VideoFrame LoadImageFile(hstring filePath)
{
int64_t freq = clockFrequency(), t0, t1;
t0 = clockCounter();
VideoFrame inputImage = nullptr;
try
{
// open the file
StorageFile file = StorageFile::GetFileFromPathAsync(filePath).get();
// get a stream on it
auto stream = file.OpenAsync(FileAccessMode::Read).get();
// Create the decoder from the stream
BitmapDecoder decoder = BitmapDecoder::CreateAsync(stream).get();
// get the bitmap
SoftwareBitmap softwareBitmap = decoder.GetSoftwareBitmapAsync().get();
// load a videoframe from it
inputImage = VideoFrame::CreateWithSoftwareBitmap(softwareBitmap);
}
catch (...)
{
printf("ERROR:failed to load the image file, make sure you are using fully qualified paths\r\n");
exit(EXIT_FAILURE);
}
t1 = clockCounter();
printf("MIVisionX: Image file loading took -- %.3f msec\n", (float)(t1 - t0)*1000.0f / (float)freq);
// all done
return inputImage;
}
// bind the ONNX model
void BindModel(hstring inputTensorName, hstring outputTensorName, int64_t *outputDim)
{
int64_t freq = clockFrequency(), t0, t1;
t0 = clockCounter();
// now create a session and binding
session = LearningModelSession{ model, LearningModelDevice(deviceKindArray[deviceIndex]) };
binding = LearningModelBinding{ session };
// bind the intput image
binding.Bind(inputTensorName, ImageFeatureValue::CreateFromVideoFrame(imageFrame));
// bind the output
vector<int64_t> shape({ outputDim[0], outputDim[1], outputDim[2], outputDim[3] });
binding.Bind(outputTensorName, TensorFloat::Create(shape));
t1 = clockCounter();
printf("MIVisionX: Model file binding took -- %.3f msec\n", (float)(t1 - t0)*1000.0f / (float)freq);
}
// load label.txt
void LoadLabels()
{
// Parse labels from labels file. We know the file's entries are already sorted in order.
ifstream labelFile{ labelsFilePath, ifstream::in };
if (labelFile.fail())
{
printf("ERROR:failed to load the %s file. Make sure it exists in the same folder as the app\r\n", labelsFilePath.c_str());
exit(EXIT_FAILURE);
}
std::string s;
while (std::getline(labelFile, s, ','))
{
int labelValue = atoi(s.c_str());
if (labelValue >= labels.size())
{
labels.resize(labelValue + 1);
}
std::getline(labelFile, s);
labels[labelValue] = s;
}
}
// print results on screen
void PrintResults(IVectorView<float> results)
{
// load the labels
LoadLabels();
// Find the top 3 probabilities
vector<float> topProbabilities(3);
vector<int> topProbabilityLabelIndexes(3);
// SqueezeNet returns a list of 1000 options, with probabilities for each, loop through all
for (uint32_t i = 0; i < results.Size(); i++)
{
// is it one of the top 3?
for (int j = 0; j < 3; j++)
{
if (results.GetAt(i) > topProbabilities[j])
{
topProbabilityLabelIndexes[j] = i;
topProbabilities[j] = results.GetAt(i);
break;
}
}
}
// Display the result
for (int i = 0; i < 3; i++)
{
printf("Top-%d: %s with confidence of %f\n", i+1, labels[topProbabilityLabelIndexes[i]].c_str(), topProbabilities[i]);
}
}
// run inference
void EvaluateModel(hstring modelOutputTensorName)
{
// now run the model
int64_t freq = clockFrequency(), t0, t1;
t0 = clockCounter();
auto results = session.Evaluate(binding, L"RunId");
t1 = clockCounter();
printf("MIVisionX: Model first run took -- %.3f msec\n", (float)(t1-t0)*1000.0f/(float)freq);
// get the output
auto resultTensor = results.Outputs().Lookup(modelOutputTensorName).as<TensorFloat>();
auto resultVector = resultTensor.GetAsVectorView();
PrintResults(resultVector);
}
// run inference for timing
void EvaluateModelPlain()
{
auto results = session.Evaluate(binding, L"RunId");
}
// main entry function
int main(int argc, char * argv[])
{
int status = 0;
char *modelFileLocation = NULL, *modelInputName = NULL, *modelOutputName = NULL;
char *modelOutputSize = NULL, *labelFileLocation = NULL, *imageFileLocation = NULL;
int parameter = 0;
// device set to DirectXHighPerformance
deviceIndex = 3;
for (int arg = 1; arg < argc; arg++)
{
if (!strcasecmp(argv[arg], "--help") || !strcasecmp(argv[arg], "--H") || !strcasecmp(argv[arg], "--h"))
{
show_usage();
exit(status);
}
else if (!strcasecmp(argv[arg], "--model") || !strcasecmp(argv[arg], "--M") || !strcasecmp(argv[arg], "--m"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing ONNX .model file location on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
modelFileLocation = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--inputName") || !strcasecmp(argv[arg], "--I") || !strcasecmp(argv[arg], "--i"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing model input tensor name on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
modelInputName = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--outputName") || !strcasecmp(argv[arg], "--O") || !strcasecmp(argv[arg], "--o"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing model output tensor name on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
modelOutputName = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--outputSize") || !strcasecmp(argv[arg], "--S") || !strcasecmp(argv[arg], "--s"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing model output tensor size on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
modelOutputSize = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--label") || !strcasecmp(argv[arg], "--L") || !strcasecmp(argv[arg], "--l"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing label.txt file on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
labelFileLocation = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--imageFrame") || !strcasecmp(argv[arg], "--F") || !strcasecmp(argv[arg], "--f"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing image.png file on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
imageFileLocation = (argv[arg]);
parameter++;
}
else if (!strcasecmp(argv[arg], "--deviceKind") || !strcasecmp(argv[arg], "--D") || !strcasecmp(argv[arg], "--d"))
{
if ((arg + 1) == argc)
{
printf("\n\nERROR: missing device kind index on command-line (see help for details)\n\n\n");
show_usage();
status = -1;
exit(status);
}
arg++;
deviceIndex = atoi(argv[arg]);
if (deviceIndex > 4) deviceIndex = 0;
}
}
// check if all the parameters needed was passed
if (parameter != 6)
{
printf("\nERROR: missing parameters in command-line. Please check help for details\n");
show_usage();
status = -1;
exit(status);
}
// get model location
std::string Model(modelFileLocation);
wstring wModel(Model.begin(), Model.end());
hstring modelLocation = wModel.c_str();
// get model input tensor name
std::string inputName(modelInputName);
wstring wInputName(inputName.begin(), inputName.end());
hstring modelInputTensorName = wInputName.c_str();
// get model output tensor name
std::string outputName(modelOutputName);
wstring wOutputName(outputName.begin(), outputName.end());
hstring modelOutputTensorName = wOutputName.c_str();
// get model output tensor size
std::string outputSize(modelOutputSize);
std::vector<int> sizeVector;
std::stringstream sizeStream(outputSize);
int i;
while (sizeStream >> i)
{
sizeVector.push_back(i);
if (sizeStream.peek() == ',')
sizeStream.ignore();
}
if (sizeVector.size() != 2 && sizeVector.size() != 4)
{
printf("\nERROR:Output Tensor Size: %d. Please check help for details\n", sizeVector.size());
show_usage();
status = -1;
exit(status);
}
int64_t outputDims[4] = { 0 };
for (i = 0; i < sizeVector.size(); i++)
outputDims[i] = sizeVector.at(i);
// get label.txt location
std::string labelLocation(labelFileLocation);
labelsFilePath = labelLocation;
// get image location
std::string Image(imageFileLocation);
wstring wImage(Image.begin(), Image.end());
hstring imageLocation = wImage.c_str();
// load model
LoadModelFromPath(modelLocation);
// load image
imageFrame = LoadImageFile(imageLocation);
// bind model
BindModel(modelInputTensorName, modelOutputTensorName, outputDims);
// run inference
EvaluateModel(modelOutputTensorName);
// get avg inference time in msec
int64_t freq = clockFrequency(), t0, t1;
t0 = clockCounter();
for (i = 0; i < 100; i++)
EvaluateModelPlain();
t1 = clockCounter();
printf("MIVisionX: Avg model run run time for 100 iterations -- %.3f msec\n\n", (float)((t1 - t0)/100)*1000.0f / (float)freq);
return status;
}
| 32.792105
| 149
| 0.654843
|
Indumathi31
|
e782a4e227c4c146fe76286be7a466a8071860b5
| 528
|
hpp
|
C++
|
include/burndown/parser.hpp
|
winsider/burndown
|
fe1242ead437002184d4062797a8c0387cdd7fcc
|
[
"MIT"
] | null | null | null |
include/burndown/parser.hpp
|
winsider/burndown
|
fe1242ead437002184d4062797a8c0387cdd7fcc
|
[
"MIT"
] | null | null | null |
include/burndown/parser.hpp
|
winsider/burndown
|
fe1242ead437002184d4062797a8c0387cdd7fcc
|
[
"MIT"
] | null | null | null |
#pragma once
#include <string>
#include <vector>
#include <burndown/string_segment.hpp>
namespace ltc
{
namespace bd
{
/**
* Parse buffer with csp template data
*
* \param csp_txt Buffer with CSP data
*/
std::vector<string_segment> parse_csp_buffer(const std::vector<char>& csp_txt);
/**
* Parse csp file.
* \param filepath Full path and name to csp file
*/
void parse_csp_file(const std::string& filepath);
}
}
| 22.956522
| 87
| 0.573864
|
winsider
|
e7899ddaaaf11e9348d60698ee382a470bf9d35e
| 1,464
|
cpp
|
C++
|
frameworks/qt/libs/util/dmzQtUtil.cpp
|
tongli/dmz
|
f2242027a17ea804259f9412b07d69f719a527c5
|
[
"MIT"
] | 1
|
2016-05-08T22:02:35.000Z
|
2016-05-08T22:02:35.000Z
|
frameworks/qt/libs/util/dmzQtUtil.cpp
|
ashok/dmz
|
2f8d4bced646f25abf2e98bdc0d378dafb4b32ed
|
[
"MIT"
] | null | null | null |
frameworks/qt/libs/util/dmzQtUtil.cpp
|
ashok/dmz
|
2f8d4bced646f25abf2e98bdc0d378dafb4b32ed
|
[
"MIT"
] | null | null | null |
#include <dmzQtUtil.h>
#include <math.h>
#include <QtGui/QtGui>
dmz::Float64
dmz::get_qmatrix_scale (const QMatrix &Source) {
qreal scaleX = Source.m11 ();
qreal scaleY = Source.m12 ();
qreal scale = sqrt (scaleX * scaleX + scaleY + scaleY);
return scale;
}
void
dmz::set_qobject_properties (const String &Name, const Config &Source, QObject *object) {
if (object) {
Config properties;
if (Name) { Source.lookup_all_config_merged (Name, properties); }
else { properties = Source; }
ConfigIterator it;
Config cd;
while (properties.get_next_config (it, cd)) {
const QVariant Value (config_to_string ("value", cd).get_buffer ());
object->setProperty (cd.get_name ().get_buffer (), Value);
}
}
}
dmz::Boolean
dmz::set_qwidget_stylesheet (const String &Name, const Config &Source, QWidget *widget) {
Boolean result (False);
if (widget) {
Config cd;
if (Name) { Source.lookup_config (Name, cd); }
else { cd = Source; }
String qss (config_to_string ("file", cd));
if (qss) {
QFile file (qss.get_buffer ());
if (file.open (QFile::ReadOnly)) {
QString styleSheet (QLatin1String (file.readAll ()));
widget->setStyleSheet (styleSheet);
qDebug () << widget->objectName () << "Style Sheet:" << qss.get_buffer ();
result = True;
}
}
}
return result;
}
| 20.914286
| 89
| 0.599044
|
tongli
|
e78a7495dc31b658e56b1ac6c1de7d0089ab3979
| 15,856
|
cpp
|
C++
|
engine/graphics/opengl/android/OGLRenderDeviceAndroid.cpp
|
tsukoyumi/ouzel
|
43f4f4871d49a310529366a4a4db061a96097164
|
[
"Unlicense"
] | null | null | null |
engine/graphics/opengl/android/OGLRenderDeviceAndroid.cpp
|
tsukoyumi/ouzel
|
43f4f4871d49a310529366a4a4db061a96097164
|
[
"Unlicense"
] | null | null | null |
engine/graphics/opengl/android/OGLRenderDeviceAndroid.cpp
|
tsukoyumi/ouzel
|
43f4f4871d49a310529366a4a4db061a96097164
|
[
"Unlicense"
] | null | null | null |
// Ouzel by Elviss Strazdins
#include "../../../core/Setup.h"
#if defined(__ANDROID__) && OUZEL_COMPILE_OPENGL
#include <algorithm>
#include "OGLRenderDeviceAndroid.hpp"
#include "../EGLErrorCategory.hpp"
#include "../../../core/Engine.hpp"
#include "../../../core/Window.hpp"
#include "../../../core/android/NativeWindowAndroid.hpp"
#include "../../../utils/Log.hpp"
#include "../../../utils/Utils.hpp"
namespace ouzel::graphics::opengl::android
{
namespace
{
const egl::ErrorCategory eglErrorCategory{};
std::vector<EGLConfig> chooseConfig(EGLDisplay display,
bool depth,
bool stencil,
std::uint32_t sampleCount,
EGLint version)
{
const EGLint attributeList[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, depth ? 24 : 0,
EGL_STENCIL_SIZE, stencil ? 8 : 0,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
#if OUZEL_OPENGLES
EGL_RENDERABLE_TYPE, (version >= 3) ? EGL_OPENGL_ES3_BIT :
(version == 2) ? EGL_OPENGL_ES2_BIT :
EGL_OPENGL_ES_BIT,
#else
EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
#endif
EGL_SAMPLE_BUFFERS, (sampleCount > 1) ? 1 : 0,
EGL_SAMPLES, static_cast<EGLint>(sampleCount),
EGL_NONE
};
EGLint configCount;
if (!eglChooseConfig(display, attributeList, nullptr, 0, &configCount))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to choose EGL config"};
if (configCount == 0) return {};
std::vector<EGLConfig> configs(configCount);
if (!eglChooseConfig(display, attributeList, configs.data(), configCount, &configCount))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to choose EGL config"};
return configs;
}
}
RenderDevice::RenderDevice(const Settings& settings,
core::Window& initWindow):
opengl::RenderDevice{settings, initWindow}
{
embedded = true;
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (display == EGL_NO_DISPLAY)
throw std::runtime_error{"Failed to get display"};
if (!eglInitialize(display, nullptr, nullptr))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to initialize EGL"};
const auto eglVersionPtr = eglQueryString(display, EGL_VERSION);
if (!eglVersionPtr)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get EGL version"};
log(Log::Level::all) << "EGL version: " << eglVersionPtr;
const auto eglExtensionsPtr = eglQueryString(display, EGL_EXTENSIONS);
if (!eglExtensionsPtr)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get EGL extensions"};
const auto eglExtensions = explodeString(eglExtensionsPtr, ' ');
log(Log::Level::all) << "Supported EGL extensions: " << eglExtensions;
const auto& windowAndroid = window.getNativeWindow();
if (std::find(eglExtensions.begin(), eglExtensions.end(), "EGL_KHR_create_context") != eglExtensions.end())
{
const auto configs = chooseConfig(display, settings.depth, settings.stencil, settings.sampleCount, 3);
if (!configs.empty())
{
if (!eglBindAPI(EGL_OPENGL_ES_API))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to bind OpenGL ES API"};
EGLint format;
if (!eglGetConfigAttrib(display, configs[0], EGL_NATIVE_VISUAL_ID, &format))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get config attribute"};
ANativeWindow_setBuffersGeometry(windowAndroid.getNativeWindow(), 0, 0, format);
surface = eglCreateWindowSurface(display, configs[0], windowAndroid.getNativeWindow(), nullptr);
if (surface == EGL_NO_SURFACE)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL window surface"};
const EGLint contextAttributes[] = {
EGL_CONTEXT_MAJOR_VERSION, 3,
EGL_CONTEXT_MINOR_VERSION, 0,
EGL_CONTEXT_FLAGS_KHR, settings.debugRenderer ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0,
EGL_NONE
};
context = eglCreateContext(display, configs[0], EGL_NO_CONTEXT, contextAttributes);
if (context != EGL_NO_CONTEXT)
apiVersion = ApiVersion{3, 0};
else // TODO: use RAII for surface
eglDestroySurface(display, surface);
}
}
if (context == EGL_NO_CONTEXT)
{
const auto configs = chooseConfig(display, settings.depth, settings.stencil, settings.sampleCount, 2);
if (configs.empty())
throw std::runtime_error{"No EGL config found"};
if (!eglBindAPI(EGL_OPENGL_ES_API))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to bind OpenGL ES API"};
EGLint format;
if (!eglGetConfigAttrib(display, configs[0], EGL_NATIVE_VISUAL_ID, &format))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get config attribute"};
const auto& windowAndroid = window.getNativeWindow();
ANativeWindow_setBuffersGeometry(windowAndroid.getNativeWindow(), 0, 0, format);
surface = eglCreateWindowSurface(display, configs[0], windowAndroid.getNativeWindow(), nullptr);
if (surface == EGL_NO_SURFACE)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL window surface"};
const EGLint contextAttributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, configs[0], EGL_NO_CONTEXT, contextAttributes);
if (context == EGL_NO_CONTEXT)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL context"};
apiVersion = ApiVersion{2, 0};
}
log(Log::Level::info) << "EGL OpenGL ES " << apiVersion.v[0] << " context created";
if (!eglMakeCurrent(display, surface, surface, context))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to set current EGL context"};
if (!eglSwapInterval(display, settings.verticalSync ? 1 : 0))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to set EGL frame interval"};
EGLint surfaceWidth;
EGLint surfaceHeight;
if (!eglQuerySurface(display, surface, EGL_WIDTH, &surfaceWidth) ||
!eglQuerySurface(display, surface, EGL_HEIGHT, &surfaceHeight))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get query window size"};
init(surfaceWidth, surfaceHeight);
if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to unset EGL context"};
}
RenderDevice::~RenderDevice()
{
running = false;
CommandBuffer commandBuffer;
commandBuffer.pushCommand(std::make_unique<PresentCommand>());
submitCommandBuffer(std::move(commandBuffer));
if (renderThread.isJoinable()) renderThread.join();
if (display != EGL_NO_DISPLAY)
{
if (context != EGL_NO_CONTEXT)
{
eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(display, context);
}
if (surface != EGL_NO_SURFACE)
eglDestroySurface(display, surface);
eglTerminate(display);
}
}
void RenderDevice::start()
{
running = true;
renderThread = thread::Thread{&RenderDevice::renderMain, this};
}
void RenderDevice::reload()
{
running = false;
CommandBuffer commandBuffer;
commandBuffer.pushCommand(std::make_unique<PresentCommand>());
submitCommandBuffer(std::move(commandBuffer));
if (renderThread.isJoinable()) renderThread.join();
const auto eglExtensionsPtr = eglQueryString(display, EGL_EXTENSIONS);
if (!eglExtensionsPtr)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get EGL extensions"};
const auto eglExtensions = explodeString(eglExtensionsPtr, ' ');
log(Log::Level::all) << "Supported EGL extensions: " << eglExtensions;
const auto& windowAndroid = window.getNativeWindow();
if (std::find(eglExtensions.begin(), eglExtensions.end(), "EGL_KHR_create_context") != eglExtensions.end())
{
const auto configs = chooseConfig(display, depth, stencil, sampleCount, 3);
if (!configs.empty())
{
if (!eglBindAPI(EGL_OPENGL_ES_API))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to bind OpenGL ES API"};
EGLint format;
if (!eglGetConfigAttrib(display, configs[0], EGL_NATIVE_VISUAL_ID, &format))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get config attribute"};
ANativeWindow_setBuffersGeometry(windowAndroid.getNativeWindow(), 0, 0, format);
surface = eglCreateWindowSurface(display, configs[0], windowAndroid.getNativeWindow(), nullptr);
if (surface == EGL_NO_SURFACE)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL window surface"};
const EGLint contextAttributes[] = {
EGL_CONTEXT_MAJOR_VERSION, 3,
EGL_CONTEXT_MINOR_VERSION, 0,
EGL_CONTEXT_FLAGS_KHR, debugRenderer ? EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0,
EGL_NONE
};
context = eglCreateContext(display, configs[0], EGL_NO_CONTEXT, contextAttributes);
if (context != EGL_NO_CONTEXT)
{
apiVersion = ApiVersion{3, 0};
log(Log::Level::info) << "EGL OpenGL ES " << 3 << " context created";
}
else // TODO: use RAII for surface
eglDestroySurface(display, surface);
}
}
if (context == EGL_NO_CONTEXT)
{
const auto configs = chooseConfig(display, depth, stencil, sampleCount, 2);
if (configs.empty())
throw std::runtime_error{"No EGL config found"};
if (!eglBindAPI(EGL_OPENGL_ES_API))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to bind OpenGL ES API"};
EGLint format;
if (!eglGetConfigAttrib(display, configs[0], EGL_NATIVE_VISUAL_ID, &format))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get config attribute"};
const auto& windowAndroid = window.getNativeWindow();
ANativeWindow_setBuffersGeometry(windowAndroid.getNativeWindow(), 0, 0, format);
surface = eglCreateWindowSurface(display, configs[0], windowAndroid.getNativeWindow(), nullptr);
if (surface == EGL_NO_SURFACE)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL window surface"};
const EGLint contextAttributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
context = eglCreateContext(display, configs[0], EGL_NO_CONTEXT, contextAttributes);
if (context == EGL_NO_CONTEXT)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to create EGL context"};
apiVersion = ApiVersion{2, 0};
log(Log::Level::info) << "EGL OpenGL ES " << 2 << " context created";
}
if (!eglMakeCurrent(display, surface, surface, context))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to set current EGL context"};
if (!eglSwapInterval(display, verticalSync ? 1 : 0))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to set EGL frame interval"};
EGLint surfaceWidth;
EGLint surfaceHeight;
if (!eglQuerySurface(display, surface, EGL_WIDTH, &surfaceWidth) ||
!eglQuerySurface(display, surface, EGL_HEIGHT, &surfaceHeight))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to get query window size"};
frameBufferWidth = surfaceWidth;
frameBufferHeight = surfaceHeight;
stateCache = StateCache();
glDisableProc(GL_DITHER);
glDepthFuncProc(GL_LEQUAL);
if (const auto error = glGetErrorProc(); error != GL_NO_ERROR)
throw std::system_error{makeErrorCode(error), "Failed to set depth function"};
if (glGenVertexArraysProc) glGenVertexArraysProc(1, &vertexArrayId);
for (const auto& resource : resources)
if (resource) resource->invalidate();
for (const auto& resource : resources)
if (resource) resource->restore();
if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to unset EGL context"};
running = true;
renderThread = thread::Thread{&RenderDevice::renderMain, this};
}
void RenderDevice::destroy()
{
running = false;
CommandBuffer commandBuffer;
commandBuffer.pushCommand(std::make_unique<PresentCommand>());
submitCommandBuffer(std::move(commandBuffer));
if (renderThread.isJoinable()) renderThread.join();
if (context)
{
if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
log(Log::Level::error) << "Failed to unset EGL context";
if (!eglDestroyContext(display, context))
log(Log::Level::error) << "Failed to destroy EGL context";
context = nullptr;
}
if (surface)
{
if (!eglDestroySurface(display, surface))
log(Log::Level::error) << "Failed to destroy EGL surface";
surface = nullptr;
}
}
void RenderDevice::present()
{
if (eglSwapBuffers(display, surface) != EGL_TRUE)
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to swap buffers"};
}
void RenderDevice::renderMain()
{
if (!eglMakeCurrent(display, surface, surface, context))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to set current EGL context"};
while (running)
{
try
{
process();
}
catch (const std::exception& e)
{
log(Log::Level::error) << e.what();
}
}
if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
throw std::system_error{eglGetError(), eglErrorCategory, "Failed to unset EGL context"};
}
}
#endif
| 40.243655
| 116
| 0.60135
|
tsukoyumi
|
e78feb19e9af87d73f00bc2d2232fd9613159261
| 393
|
cpp
|
C++
|
2016-maximum-difference-between-increasing-elements/2016-maximum-difference-between-increasing-elements.cpp
|
SouvikChan/-Leetcode_Souvik
|
cc4b72cb4a14a1c6b8be8bd8390de047443fe008
|
[
"MIT"
] | null | null | null |
2016-maximum-difference-between-increasing-elements/2016-maximum-difference-between-increasing-elements.cpp
|
SouvikChan/-Leetcode_Souvik
|
cc4b72cb4a14a1c6b8be8bd8390de047443fe008
|
[
"MIT"
] | null | null | null |
2016-maximum-difference-between-increasing-elements/2016-maximum-difference-between-increasing-elements.cpp
|
SouvikChan/-Leetcode_Souvik
|
cc4b72cb4a14a1c6b8be8bd8390de047443fe008
|
[
"MIT"
] | null | null | null |
class Solution {
public:
int maximumDifference(vector<int>& nums) {
int n=nums.size();
int dif=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
if(nums[i]<nums[j] && i<j){
dif=max((nums[j]-nums[i]),dif);
}
}
}
if(dif==0)
return -1;
return dif;
}
};
| 23.117647
| 51
| 0.379135
|
SouvikChan
|
e79339d8380068bb8c9df637b649068911060de7
| 419
|
cpp
|
C++
|
01.02-variadicTemplateSum1/main.cpp
|
curtkim/programming-with-cpp20
|
7f2e4441e3ea550a9177499b0805481efc23685d
|
[
"MIT"
] | null | null | null |
01.02-variadicTemplateSum1/main.cpp
|
curtkim/programming-with-cpp20
|
7f2e4441e3ea550a9177499b0805481efc23685d
|
[
"MIT"
] | null | null | null |
01.02-variadicTemplateSum1/main.cpp
|
curtkim/programming-with-cpp20
|
7f2e4441e3ea550a9177499b0805481efc23685d
|
[
"MIT"
] | null | null | null |
// Copyright (c) Andreas Fertig.
// SPDX-License-Identifier: MIT
#include <cstdio>
#include <type_traits>
template<typename T, typename... Ts>
inline constexpr bool are_same_v =
std::conjunction_v<std::is_same<T, Ts>...>;
template<typename... Args>
auto add(Args&&... args)
{
static_assert(are_same_v<Args...>);
return (... + args);
}
int main()
{
printf("%d\n", add(2, 3, 4));
printf("%d\n", add(2));
}
| 17.458333
| 45
| 0.639618
|
curtkim
|
e794dd27b5ee186d36ca63a6c095d14583731dea
| 1,099
|
cc
|
C++
|
src/reindexer/core/perfstatcounter.cc
|
arock121/pocketnet.core
|
bc08bf9dc565c60d7e7d53e3cc615408b76f9bde
|
[
"ECL-2.0",
"Apache-2.0"
] | 72
|
2019-06-23T07:48:03.000Z
|
2022-03-31T03:47:04.000Z
|
src/reindexer/core/perfstatcounter.cc
|
arock121/pocketnet.core
|
bc08bf9dc565c60d7e7d53e3cc615408b76f9bde
|
[
"ECL-2.0",
"Apache-2.0"
] | 153
|
2021-01-20T08:10:23.000Z
|
2022-03-31T23:30:50.000Z
|
src/reindexer/core/perfstatcounter.cc
|
arock121/pocketnet.core
|
bc08bf9dc565c60d7e7d53e3cc615408b76f9bde
|
[
"ECL-2.0",
"Apache-2.0"
] | 20
|
2019-10-10T22:18:25.000Z
|
2022-02-12T01:08:29.000Z
|
#include "perfstatcounter.h"
#include "estl/shared_mutex.h"
namespace reindexer {
template <typename Mutex>
void PerfStatCounter<Mutex>::Hit(std::chrono::microseconds time) {
std::unique_lock<Mutex> lck(mtx_);
totalTime += time;
calcTime += time;
calcHitCount++;
totalHitCount++;
lap();
}
template <typename Mutex>
void PerfStatCounter<Mutex>::LockHit(std::chrono::microseconds time) {
std::unique_lock<Mutex> lck(mtx_);
calcLockTime += time;
totalLockTime += time;
}
template <typename Mutex>
void PerfStatCounter<Mutex>::lap() {
auto now = std::chrono::high_resolution_clock::now();
std::chrono::microseconds elapsed = std::chrono::duration_cast<std::chrono::microseconds>(now - calcStartTime);
if (elapsed < std::chrono::microseconds(1000000)) return;
avgHitCount = calcHitCount;
avgTime = calcTime;
calcTime = std::chrono::microseconds(0);
avgLockTime = calcLockTime;
calcLockTime = std::chrono::microseconds(0);
calcHitCount = 0;
calcStartTime = now;
}
template class PerfStatCounter<std::mutex>;
template class PerfStatCounter<dummy_mutex>;
} // namespace reindexer
| 26.166667
| 112
| 0.744313
|
arock121
|
e79c0d1778b4cde8c5ba93a0b52a63d628bca142
| 3,061
|
cpp
|
C++
|
tests/src/parse_string_tests.cpp
|
stac47/jsoncons
|
b9e95d6a0bcb2dc8a821d33f98a530f10cfe1bc0
|
[
"BSL-1.0"
] | null | null | null |
tests/src/parse_string_tests.cpp
|
stac47/jsoncons
|
b9e95d6a0bcb2dc8a821d33f98a530f10cfe1bc0
|
[
"BSL-1.0"
] | null | null | null |
tests/src/parse_string_tests.cpp
|
stac47/jsoncons
|
b9e95d6a0bcb2dc8a821d33f98a530f10cfe1bc0
|
[
"BSL-1.0"
] | 2
|
2020-09-15T13:00:19.000Z
|
2020-11-13T13:17:44.000Z
|
// Copyright 2016 Daniel Parker
// Distributed under Boost license
#include <jsoncons/json.hpp>
#include <jsoncons/json_encoder.hpp>
#include <jsoncons/json_reader.hpp>
#include <catch/catch.hpp>
#include <sstream>
#include <vector>
#include <utility>
#include <ctime>
using namespace jsoncons;
struct jsonpath_filter_fixture
{
};
class lenient_error_handler
{
std::error_code value_;
public:
lenient_error_handler(std::error_code value)
: value_(value)
{
}
bool operator()(std::error_code ec, const ser_context&) noexcept
{
return ec == value_; // if returns true, use default processing
}
};
TEST_CASE("test_parse_small_string1")
{
std::string input = "\"String\"";
json_decoder<json> decoder;
JSONCONS_TRY
{
json_reader reader(input,decoder);
reader.read_next();
}
JSONCONS_CATCH (const std::exception&)
{
}
CHECK(decoder.is_valid());
}
TEST_CASE("test_parse_small_string2")
{
std::string input = "\"Str\\\"ing\"";
json_decoder<json> decoder;
JSONCONS_TRY
{
json_reader reader(input, decoder);
reader.read_next();
}
JSONCONS_CATCH (const std::exception&)
{
}
CHECK(decoder.is_valid());
}
TEST_CASE("test_parse_small_string4")
{
std::string input = "\"Str\\\"ing\"";
for (std::size_t i = 2; i < input.length(); ++i)
{
std::istringstream is(input);
json_decoder<json> decoder;
JSONCONS_TRY
{
json_reader reader(is, decoder);
reader.buffer_length(i);
reader.read_next();
}
JSONCONS_CATCH (const std::exception&)
{
}
CHECK(decoder.is_valid());
CHECK(std::string("Str\"ing") == decoder.get_result().as<std::string>());
}
}
TEST_CASE("test_parse_big_string1")
{
std::string input = "\"Big Str\\\"ing\"";
for (std::size_t i = 2; i < input.length(); ++i)
{
std::istringstream is(input);
json_decoder<json> decoder;
JSONCONS_TRY
{
json_reader reader(is, decoder);
reader.buffer_length(i);
reader.read_next();
}
JSONCONS_CATCH (const std::exception&)
{
}
CHECK(decoder.is_valid());
CHECK(std::string("Big Str\"ing") == decoder.get_result().as<std::string>());
}
}
TEST_CASE("test_parse_big_string2")
{
std::string input = "\"Big\t Str\\\"ing\"";
//for (std::size_t i = 2; i < input.length(); ++i)
//{
std::istringstream is(input);
json_decoder<json> decoder;
lenient_error_handler err_handler(json_errc::illegal_character_in_string);
JSONCONS_TRY
{
json_reader reader(is, decoder, err_handler);
//reader.buffer_length(i);
reader.read_next();
}
JSONCONS_CATCH (const std::exception&)
{
}
CHECK(decoder.is_valid());
CHECK(std::string("Big\t Str\"ing") == decoder.get_result().as<std::string>());
//}
}
| 23.015038
| 87
| 0.590003
|
stac47
|
e79e0c8f527fcec565ec54f980be810dc9b7c57d
| 3,618
|
cpp
|
C++
|
PROJECTS/smarthome/hub/multiregistrar/registrar.cpp
|
afatom/core-program
|
7886acf67f6b81bd06edef41f6ddab83cc993927
|
[
"MIT"
] | null | null | null |
PROJECTS/smarthome/hub/multiregistrar/registrar.cpp
|
afatom/core-program
|
7886acf67f6b81bd06edef41f6ddab83cc993927
|
[
"MIT"
] | null | null | null |
PROJECTS/smarthome/hub/multiregistrar/registrar.cpp
|
afatom/core-program
|
7886acf67f6b81bd06edef41f6ddab83cc993927
|
[
"MIT"
] | null | null | null |
#include <multiregistrar.h>
typedef std::map<const string, vector<Ilistener_t*> > SingleMap;
typedef std::map<const string, map <const string, vector<Ilistener_t*> > > DualMap;
typedef std::map<const string, map < const string, map <const string, vector<Ilistener_t*> > > > TrippleMap;
MRegistrar_t::MRegistrar_t()
{
m_container = new IlistenersContainer;
if(pthread_mutex_init(&m_mutex, NULL) != 0)
{
//throw exception;
}
}
MRegistrar_t::~MRegistrar_t()
{
delete m_container;
m_container = 0;
pthread_mutex_destroy(&m_mutex);
}
void MRegistrar_t::Subscribe(Ilistener_t* _pListiner, SubscribingSet& _set)
{
pthread_mutex_lock(&m_mutex);
if(_set.m_floor != "all" && _set.m_room != "all")
{
//specific type,floor,room subscribing
((((*m_container)[_set.m_eventType])[_set.m_floor])[_set.m_room]).push_back(_pListiner);
}
else if(_set.m_floor != "all" && _set.m_room == "all")
{
SubscribeOnAllRooms(_set.m_eventType, _set.m_floor, _pListiner);
}
else
{
//all floors and all rooms
SubscribeOnAllFloors(_set.m_eventType ,_pListiner);
}
pthread_mutex_unlock(&m_mutex);
}
void MRegistrar_t::SubscribeOnAllRooms(const string& _eventType, const string& _floor, Ilistener_t* _pListiner)
{
SingleMap::iterator itb = (((*m_container)[_eventType])[_floor]).begin();
SingleMap::iterator ite = (((*m_container)[_eventType])[_floor]).end();
while(itb!=ite)
{
//push the _pListiner to itb vector
(*(itb->second)).push_back(_pListiner);
++itb;
}
}
void MRegistrar_t::SubscribeOnAllFloors(const string& _eventType ,Ilistener_t* _pListiner)
{
std::map<const string, map < const string, vector<Ilistener_t*> > >::iterator itb = (((*m_container)[_eventType])).begin();
std::map<const string, map < const string, vector<Ilistener_t*> > >::iterator ite = (((*m_container)[_eventType]).end();
while(itb != ite)
{
//push the _pListiner to itb vector
SubscribeOnAllRooms(_eventType, (*(itb->first)), _pListiner);
++itb;
}
}
map<Ilistener_t*,int>* MRegistrar_t::GetSubscribers(SubscribingSet& _set)
{
pthread_mutex_lock(&m_mutex);
map<Ilistener_t*,int>* retval = new map<Ilistener_t*,int>;
if(_set.m_floor != "all" && _set.m_room != "all")
{
retval = VectorToMap(&((((*m_container)[_set.m_eventType])[_set.m_floor])[_set.m_room]));
}
else if(_set.m_floor != "all" && _set.m_room == "all")
{
SingleMap::iterator itb = (((*m_container)[_set.m_eventType])[_set.m_floor]).begin();
SingleMap::iterator ite = (((*m_container)[_set.m_eventType])[_set.m_floor]).end();
RoomsMapToMyMap(itb, ite, retval);
}
else
{
DualMap::iterator itb = ((*m_container)[_set.m_eventType]).begin();
DualMap::iterator ite = ((*m_container)[_set.m_eventType]).end();
FloorsMapToMyMap(itb, ite, retval);
}
pthread_mutex_unlock(&m_mutex);
return retval;
}
void VectorTurnToMyMap(vector<Ilistener_t*>* _pvec, map<Ilistener_t*,int>* _pmap)
{
size_t size = _pvec->size();
for(size_t j=0;j<size;++j)
{
_pmap->insert(std::pair<Ilistener_t*, int>((*_pvec)[j], 0));
}
}
void RoomsMapToMyMap(SingleMap::iterator _begin, SingleMap::iterator _end, map<Ilistener_t*,int>* _pmap)
{
while(_begin != _end)
{
VectorTurnToMap(_begin->second, _pmap);
++_begin;
}
}
void FloorsMapToMyMap(DualMap::iterator _begin, DualMap::iterator _end, map<Ilistener_t*,int>* _pmap)
{
while(_begin != _end)
{
SingleMap::iterator itb = (*(_begin->second)).begin();
SingleMap::iterator ite = (*(_begin->second)).end();
RoomsMapToMyMap(itb, ite, _pmap);
++_begin;
}
}
//void MRegistrar_t::UnSubscribe(Ilistener_t* _pListiner, SubscribingSet& _set)
| 25.125
| 124
| 0.694859
|
afatom
|
e79e39b55e2233cf58c603da71ec8aa82e5cc591
| 12,744
|
cpp
|
C++
|
lib/_studio/mfx_lib/shared/src/libmfxsw_plugin.cpp
|
3xLOGICKevinHan/MediaSDK
|
92b6ee70f5ea45d08527f81cb93105f9ee71d84e
|
[
"MIT"
] | null | null | null |
lib/_studio/mfx_lib/shared/src/libmfxsw_plugin.cpp
|
3xLOGICKevinHan/MediaSDK
|
92b6ee70f5ea45d08527f81cb93105f9ee71d84e
|
[
"MIT"
] | null | null | null |
lib/_studio/mfx_lib/shared/src/libmfxsw_plugin.cpp
|
3xLOGICKevinHan/MediaSDK
|
92b6ee70f5ea45d08527f81cb93105f9ee71d84e
|
[
"MIT"
] | null | null | null |
// Copyright (c) 2017 Intel Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include <mfxplugin.h>
#include <mfx_session.h>
#include <mfx_task.h>
#include <mfx_user_plugin.h>
#include <mfx_utils.h>
#define MSDK_STATIC_ASSERT(COND, MSG) typedef char static_assertion_##MSG[ (COND) ? 1 : -1];
// static section of the file
namespace
{
VideoCodecUSER *CreateUSERSpecificClass(mfxU32 type)
{
type;
return new VideoUSERPlugin;
} // VideoUSER *CreateUSERSpecificClass(mfxU32 type)
struct SessionPtr
{
private:
mfxSession _session;
std::auto_ptr<VideoCodecUSER> *_ptr;
bool _isNeedEnc;
bool _isNeedCodec;
bool _isNeedDeCoder;
bool _isNeedVPP;
mutable std::auto_ptr<VideoDECODE> _stubDecode;
mutable std::auto_ptr<VideoENCODE> _stubEncode;
mutable std::auto_ptr<VideoVPP> _stubVPP;
mutable std::auto_ptr<VideoENC> _stubEnc;
public:
SessionPtr(mfxSession session, mfxU32 type = MFX_PLUGINTYPE_VIDEO_GENERAL)
: _session(session)
{
switch(type)
{
case MFX_PLUGINTYPE_VIDEO_DECODE :
_ptr = &_session->m_plgDec;
_isNeedCodec = false;
_isNeedDeCoder = true;
_isNeedVPP = false;
_isNeedEnc = false;
break;
case MFX_PLUGINTYPE_VIDEO_ENCODE:
_ptr =&_session->m_plgEnc;
_isNeedCodec = true;
_isNeedDeCoder = false;
_isNeedVPP = false;
_isNeedEnc = false;
break;
case MFX_PLUGINTYPE_VIDEO_VPP :
_ptr = &_session->m_plgVPP;
_isNeedCodec = false;
_isNeedDeCoder = false;
_isNeedVPP = true;
_isNeedEnc = false;
break;
case MFX_PLUGINTYPE_VIDEO_ENC :
{
#if defined (MFX_PLUGIN_FILE_VERSION) || defined(MFX_PLUGIN_PRODUCT_VERSION)
MSDK_STATIC_ASSERT("This file under no conditions should appear in plugin code.");
#endif
// we know that this conversion is safe as this is library-only code
// _mfxSession_1_10 - should be used always to get versioned session instance
// interface MFXISession_1_10/MFXISession_1_10_GUID may differs
// here we use MFXISession_1_10 because it is first version which introduces Pre-Enc plugins
_mfxSession_1_10 * versionedSession = (_mfxSession_1_10 *)(session);
MFXIPtr<MFXISession_1_10> newSession(versionedSession->QueryInterface(MFXISession_1_10_GUID));
if (newSession)
{
_ptr = &newSession->GetPreEncPlugin();
_isNeedCodec = false;
_isNeedDeCoder = false;
_isNeedVPP = false;
_isNeedEnc = true;
}
else
{
throw MFX_ERR_UNDEFINED_BEHAVIOR;
}
}
break;
case MFX_PLUGINTYPE_VIDEO_GENERAL :
_ptr = &_session->m_plgGen;
_isNeedCodec = false;
_isNeedDeCoder = false;
_isNeedVPP = false;
_isNeedEnc = false;
break;
default :
//unknown plugin type
throw MFX_ERR_UNDEFINED_BEHAVIOR;
}
}
std::auto_ptr<VideoCodecUSER>& plugin()const
{
return *_ptr;
}
template <class T>
std::auto_ptr<T>& codec()const
{
}
bool isNeedEnc()const
{
return _isNeedEnc ;
}
bool isNeedEncoder()const
{
return _isNeedCodec ;
}
bool isNeedDecoder()const
{
return _isNeedDeCoder;
}
bool isNeedVPP()const
{
return _isNeedVPP;
}
};
template <>
std::auto_ptr<VideoENCODE>& SessionPtr::codec<VideoENCODE>()const
{
return _isNeedCodec ? _session->m_pENCODE : _stubEncode;
}
template <>
std::auto_ptr<VideoENC>& SessionPtr::codec<VideoENC>()const
{
return _isNeedEnc ? _session->m_pENC : _stubEnc;
}
template <>
std::auto_ptr<VideoDECODE>& SessionPtr::codec<VideoDECODE>()const
{
return _isNeedDeCoder ? _session->m_pDECODE : _stubDecode;
}
template <>
std::auto_ptr<VideoVPP>& SessionPtr::codec<VideoVPP>()const
{
return _isNeedVPP ? _session->m_pVPP : _stubVPP;
}
} // namespace
mfxStatus MFXVideoUSER_Register(mfxSession session, mfxU32 type,
const mfxPlugin *par)
{
mfxStatus mfxRes;
// check error(s)
MFX_CHECK(session, MFX_ERR_INVALID_HANDLE);
try
{
SessionPtr sessionPtr(session, type);
std::auto_ptr<VideoCodecUSER> & pluginPtr = sessionPtr.plugin();
std::auto_ptr<VideoENCODE> &encPtr = sessionPtr.codec<VideoENCODE>();
std::auto_ptr<VideoDECODE> &decPtr = sessionPtr.codec<VideoDECODE>();
std::auto_ptr<VideoVPP> &vppPtr = sessionPtr.codec<VideoVPP>();
std::auto_ptr<VideoENC> &preEncPtr = sessionPtr.codec<VideoENC>();
// the plugin with the same type is already exist
if (pluginPtr.get() || decPtr.get() || encPtr.get() || preEncPtr.get())
{
return MFX_ERR_UNDEFINED_BEHAVIOR;
}
// create a new plugin's instance
pluginPtr.reset(CreateUSERSpecificClass(type));
MFX_CHECK(pluginPtr.get(), MFX_ERR_INVALID_VIDEO_PARAM);
if (sessionPtr.isNeedDecoder()) {
decPtr.reset(pluginPtr->GetDecodePtr());
}
if (sessionPtr.isNeedEncoder()) {
encPtr.reset(pluginPtr->GetEncodePtr());
}
if (sessionPtr.isNeedVPP()) {
vppPtr.reset(pluginPtr->GetVPPPtr());
}
if (sessionPtr.isNeedEnc()) {
preEncPtr.reset(pluginPtr->GetEncPtr());
}
// initialize the plugin
mfxRes = pluginPtr->PluginInit(par, session, type);
}
catch(MFX_CORE_CATCH_TYPE)
{
// set the default error value
mfxRes = MFX_ERR_UNKNOWN;
if (0 == session)
{
mfxRes = MFX_ERR_INVALID_HANDLE;
}
/* else if (0 == registeredPlg || 0 == registeredPlg->get())
{
mfxRes = MFX_ERR_INVALID_VIDEO_PARAM;
}*/
else if (0 == par)
{
mfxRes = MFX_ERR_NULL_PTR;
}
else if (type > MFX_PLUGINTYPE_VIDEO_ENCODE)
{
mfxRes = MFX_ERR_UNDEFINED_BEHAVIOR;
}
}
return mfxRes;
} // mfxStatus MFXVideoUSER_Register(mfxSession session, mfxU32 type,
mfxStatus MFXVideoUSER_GetPlugin(mfxSession session, mfxU32 type, mfxPlugin *par)
{
mfxStatus mfxRes;
// check error(s)
MFX_CHECK(session, MFX_ERR_INVALID_HANDLE);
MFX_CHECK_NULL_PTR1(par);
try
{
SessionPtr sessionPtr(session, type);
std::auto_ptr<VideoCodecUSER> & pluginPtr = sessionPtr.plugin();
if (!pluginPtr.get())
{
return MFX_ERR_UNDEFINED_BEHAVIOR;
}
pluginPtr->GetPlugin(*par);
mfxRes = MFX_ERR_NONE;
}
catch(MFX_CORE_CATCH_TYPE)
{
// set the default error value
mfxRes = MFX_ERR_UNKNOWN;
if (0 == session)
{
mfxRes = MFX_ERR_INVALID_HANDLE;
}
else if (0 == par)
{
mfxRes = MFX_ERR_NULL_PTR;
}
else if (type > MFX_PLUGINTYPE_VIDEO_ENC)
{
mfxRes = MFX_ERR_UNDEFINED_BEHAVIOR;
}
}
return mfxRes;
} // mfxStatus MFXVideoUSER_GetPlugin(mfxSession session, mfxU32 type, mfxPlugin *par)
mfxStatus MFXVideoUSER_Unregister(mfxSession session, mfxU32 type)
{
mfxStatus mfxRes;
MFX_CHECK(session, MFX_ERR_INVALID_HANDLE);
try
{
SessionPtr sessionPtr(session, type);
std::auto_ptr<VideoCodecUSER> & registeredPlg = sessionPtr.plugin();
if (NULL == registeredPlg.get())
return MFX_ERR_NOT_INITIALIZED;
// wait until all tasks are processed
session->m_pScheduler->WaitForTaskCompletion(registeredPlg.get());
// deinitialize the plugin
mfxRes = registeredPlg->PluginClose();
// delete the plugin's instance
registeredPlg.reset();
//delete corresponding codec instance
if (sessionPtr.isNeedDecoder()) {
sessionPtr.codec<VideoDECODE>().reset();
}
if (sessionPtr.isNeedEncoder()) {
sessionPtr.codec<VideoENCODE>().reset();
}
if (sessionPtr.isNeedVPP()) {
sessionPtr.codec<VideoVPP>().reset();
}
if (sessionPtr.isNeedEnc()) {
sessionPtr.codec<VideoENC>().reset();
}
}
catch(MFX_CORE_CATCH_TYPE)
{
// set the default error value
mfxRes = MFX_ERR_UNKNOWN;
if (0 == session)
{
mfxRes = MFX_ERR_INVALID_HANDLE;
}
else if (type > MFX_PLUGINTYPE_VIDEO_ENCODE)
{
mfxRes = MFX_ERR_UNDEFINED_BEHAVIOR;
}
}
return mfxRes;
} // mfxStatus MFXVideoUSER_Unregister(mfxSession session, mfxU32 type)
mfxStatus MFXVideoUSER_ProcessFrameAsync(mfxSession session,
const mfxHDL *in, mfxU32 in_num,
const mfxHDL *out, mfxU32 out_num,
mfxSyncPoint *syncp)
{
mfxStatus mfxRes;
MFX_CHECK(session, MFX_ERR_INVALID_HANDLE);
MFX_CHECK(session->m_plgGen.get(), MFX_ERR_NOT_INITIALIZED);
MFX_CHECK(syncp, MFX_ERR_NULL_PTR);
MFX_CHECK(in_num <= MFX_TASK_NUM_DEPENDENCIES && out_num <= MFX_TASK_NUM_DEPENDENCIES, MFX_ERR_UNSUPPORTED);
try
{
//generic plugin function
std::auto_ptr<VideoCodecUSER> & registeredPlg = SessionPtr(session).plugin();
mfxSyncPoint syncPoint = NULL;
MFX_TASK task;
memset(&task, 0, sizeof(MFX_TASK));
mfxRes = registeredPlg->Check(in, in_num, out, out_num, &task.entryPoint);
// source data is OK, go forward
if (MFX_ERR_NONE == mfxRes)
{
mfxU32 i;
task.pOwner = registeredPlg.get();
task.priority = session->m_priority;
task.threadingPolicy = registeredPlg->GetThreadingPolicy();
// fill dependencies
for (i = 0; i < in_num; i += 1)
{
task.pSrc[i] = in[i];
}
for (i = 0; i < out_num; i += 1)
{
task.pDst[i] = out[i];
}
// register input and call the task
mfxRes = session->m_pScheduler->AddTask(task, &syncPoint);
}
// return pointer to synchronization point
*syncp = syncPoint;
}
catch(MFX_CORE_CATCH_TYPE)
{
// set the default error value
mfxRes = MFX_ERR_UNKNOWN;
if (0 == session)
{
return MFX_ERR_INVALID_HANDLE;
}
else if (0 == session->m_plgGen.get())
{
return MFX_ERR_NOT_INITIALIZED;
}
else if (0 == syncp)
{
return MFX_ERR_NULL_PTR;
}
}
return mfxRes;
} // mfxStatus MFXVideoUSER_ProcessFrameAsync(mfxSession session,
| 31.312039
| 114
| 0.579488
|
3xLOGICKevinHan
|
e79ebd9d3f1a4d91954888a8a46f89065e9ff6a2
| 553
|
cpp
|
C++
|
src/distance.cpp
|
dickoa/euclid
|
6588a6f56c73779152ff99eb06f41b3ec61170bc
|
[
"MIT"
] | 68
|
2020-09-17T13:17:03.000Z
|
2022-02-20T09:14:54.000Z
|
src/distance.cpp
|
dickoa/euclid
|
6588a6f56c73779152ff99eb06f41b3ec61170bc
|
[
"MIT"
] | 27
|
2020-09-17T13:35:53.000Z
|
2022-01-20T09:12:48.000Z
|
src/distance.cpp
|
dickoa/euclid
|
6588a6f56c73779152ff99eb06f41b3ec61170bc
|
[
"MIT"
] | 11
|
2020-09-17T11:43:37.000Z
|
2022-01-10T13:08:27.000Z
|
#include "geometry_vector.h"
#include "exact_numeric.h"
#include <cpp11/matrix.hpp>
#include <cpp11/external_pointer.hpp>
[[cpp11::register]]
exact_numeric_p geometry_squared_distance(geometry_vector_base_p geo1, geometry_vector_base_p geo2) {
std::vector<Exact_number> res = geo1->squared_distance(*geo2);
exact_numeric* vec(new exact_numeric(res));
return {vec};
}
[[cpp11::register]]
cpp11::writable::doubles_matrix geometry_distance_matrix(geometry_vector_base_p geo1, geometry_vector_base_p geo2) {
return geo1->distance_matrix(*geo2);
}
| 32.529412
| 116
| 0.792043
|
dickoa
|
e7a12ce94f49e99bbfdd6fd80e4ea05440370372
| 766
|
cpp
|
C++
|
src/Memory/FrameMemoryResource.cpp
|
xenginez/XE
|
7f536c906460c7062cad5b8e09a644812cabf6d3
|
[
"MIT"
] | 2
|
2019-06-10T06:51:27.000Z
|
2021-11-20T19:57:46.000Z
|
src/Memory/FrameMemoryResource.cpp
|
xenginez/XE
|
7f536c906460c7062cad5b8e09a644812cabf6d3
|
[
"MIT"
] | 1
|
2019-07-12T03:05:02.000Z
|
2019-08-12T12:01:06.000Z
|
src/Memory/FrameMemoryResource.cpp
|
xenginez/XE
|
7f536c906460c7062cad5b8e09a644812cabf6d3
|
[
"MIT"
] | null | null | null |
#include "FrameMemoryResource.h"
#include "MemoryResource.h"
XE::FrameMemoryResource::FrameMemoryResource()
:std::pmr::monotonic_buffer_resource( KBYTE( 16 ), MemoryResource::GetDefaultMemoryResource() )
{
}
XE::FrameMemoryResource::~FrameMemoryResource() noexcept
{
}
void * XE::FrameMemoryResource::do_allocate( size_t _Bytes, size_t _Align )
{
return std::pmr::monotonic_buffer_resource::allocate( _Bytes, _Align );
}
void XE::FrameMemoryResource::do_deallocate( void * _Ptr, size_t _Bytes, size_t _Align )
{
std::pmr::monotonic_buffer_resource::deallocate( _Ptr, _Bytes, _Align );
}
bool XE::FrameMemoryResource::do_is_equal( const std::pmr::memory_resource & _That ) const noexcept
{
return std::pmr::monotonic_buffer_resource::is_equal( _That );
}
| 25.533333
| 99
| 0.766319
|
xenginez
|
e7a1e9d61a3a125bb6ddbcd3f3ae7ea581885cca
| 15,656
|
cc
|
C++
|
src/xenia/cpu/frontend/ppc_emit_fpu.cc
|
Parovozik/Xenia_UI
|
3f12becc1845a8fc264ae74d25e28e543f61b5b4
|
[
"BSD-3-Clause"
] | null | null | null |
src/xenia/cpu/frontend/ppc_emit_fpu.cc
|
Parovozik/Xenia_UI
|
3f12becc1845a8fc264ae74d25e28e543f61b5b4
|
[
"BSD-3-Clause"
] | null | null | null |
src/xenia/cpu/frontend/ppc_emit_fpu.cc
|
Parovozik/Xenia_UI
|
3f12becc1845a8fc264ae74d25e28e543f61b5b4
|
[
"BSD-3-Clause"
] | 1
|
2018-10-16T16:45:27.000Z
|
2018-10-16T16:45:27.000Z
|
/*
******************************************************************************
* Xenia : Xbox 360 Emulator Research Project *
******************************************************************************
* Copyright 2013 Ben Vanik. All rights reserved. *
* Released under the BSD license - see LICENSE in the root for more details. *
******************************************************************************
*/
#include "xenia/cpu/frontend/ppc_emit-private.h"
#include "xenia/base/assert.h"
#include "xenia/cpu/frontend/ppc_context.h"
#include "xenia/cpu/frontend/ppc_hir_builder.h"
namespace xe {
namespace cpu {
namespace frontend {
// TODO(benvanik): remove when enums redefined.
using namespace xe::cpu::hir;
using xe::cpu::hir::RoundMode;
using xe::cpu::hir::Value;
// Good source of information:
// http://mamedev.org/source/src/emu/cpu/powerpc/ppc_ops.c
// The correctness of that code is not reflected here yet -_-
// Enable rounding numbers to single precision as required.
// This adds a bunch of work per operation and I'm not sure it's required.
#define ROUND_TO_SINGLE
// Floating-point arithmetic (A-8)
XEEMITTER(faddx, 0xFC00002A, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) + (frB)
Value* v = f.Add(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(faddsx, 0xEC00002A, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) + (frB)
Value* v = f.Add(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fdivx, 0xFC000024, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- frA / frB
Value* v = f.Div(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fdivsx, 0xEC000024, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- frA / frB
Value* v = f.Div(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmulx, 0xFC000032, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) x (frC)
Value* v = f.Mul(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmulsx, 0xEC000032, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) x (frC)
Value* v = f.Mul(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fresx, 0xEC000030, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- 1.0 / (frB)
Value* v = f.Convert(
f.Div(f.LoadConstant(1.0f), f.Convert(f.LoadFPR(i.A.FRB), FLOAT32_TYPE)),
FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(frsqrtex, 0xFC000034, A)(PPCHIRBuilder& f, InstrData& i) {
// Double precision:
// frD <- 1/sqrt(frB)
Value* v = f.RSqrt(f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fsubx, 0xFC000028, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) - (frB)
Value* v = f.Sub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fsubsx, 0xEC000028, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA) - (frB)
Value* v = f.Sub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fselx, 0xFC00002E, A)(PPCHIRBuilder& f, InstrData& i) {
// if (frA) >= 0.0
// then frD <- (frC)
// else frD <- (frB)
Value* ge = f.CompareSGE(f.LoadFPR(i.A.FRA), f.LoadConstant(0.0));
Value* v = f.Select(ge, f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fsqrtx, 0xFC00002C, A)(PPCHIRBuilder& f, InstrData& i) {
// Double precision:
// frD <- sqrt(frB)
Value* v = f.Sqrt(f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fsqrtsx, 0xEC00002C, A)(PPCHIRBuilder& f, InstrData& i) {
// Single precision:
// frD <- sqrt(frB)
Value* v = f.Sqrt(f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
// Floating-point multiply-add (A-9)
XEEMITTER(fmaddx, 0xFC00003A, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) + frB
Value* v =
f.MulAdd(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmaddsx, 0xEC00003A, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) + frB
Value* v =
f.MulAdd(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmsubx, 0xFC000038, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) - frB
Value* v =
f.MulSub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmsubsx, 0xEC000038, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frA x frC) - frB
Value* v =
f.MulSub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnmaddx, 0xFC00003E, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] + frB)
Value* v = f.Neg(
f.MulAdd(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB)));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnmaddsx, 0xEC00003E, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] + frB)
Value* v = f.Neg(
f.MulAdd(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB)));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnmsubx, 0xFC00003C, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] - frB)
Value* v = f.Neg(
f.MulSub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB)));
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnmsubsx, 0xEC00003C, A)(PPCHIRBuilder& f, InstrData& i) {
// frD <- -([frA x frC] - frB)
Value* v = f.Neg(
f.MulSub(f.LoadFPR(i.A.FRA), f.LoadFPR(i.A.FRC), f.LoadFPR(i.A.FRB)));
v = f.Convert(f.Convert(v, FLOAT32_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.A.FRT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
// Floating-point rounding and conversion (A-10)
XEEMITTER(fcfidx, 0xFC00069C, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- signed_int64_to_double( frB )
Value* v = f.Convert(f.Cast(f.LoadFPR(i.X.RB), INT64_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.X.RT, v);
// f.UpdateFPRF(v);
if (i.A.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fctidx, 0xFC00065C, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- double_to_signed_int64( frB )
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
Value* v = f.Convert(f.LoadFPR(i.X.RB), INT64_TYPE, round_mode);
v = f.Cast(v, FLOAT64_TYPE);
f.StoreFPR(i.X.RT, v);
// f.UpdateFPRF(v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fctidzx, 0xFC00065E, X)(PPCHIRBuilder& f, InstrData& i) {
// TODO(benvanik): assuming round to zero is always set, is that ok?
return InstrEmit_fctidx(f, i);
}
XEEMITTER(fctiwx, 0xFC00001C, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- double_to_signed_int32( frB )
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
Value* v = f.Convert(f.LoadFPR(i.X.RB), INT32_TYPE, round_mode);
v = f.Cast(f.ZeroExtend(v, INT64_TYPE), FLOAT64_TYPE);
f.StoreFPR(i.X.RT, v);
// f.UpdateFPRF(v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fctiwzx, 0xFC00001E, X)(PPCHIRBuilder& f, InstrData& i) {
// TODO(benvanik): assuming round to zero is always set, is that ok?
return InstrEmit_fctiwx(f, i);
}
XEEMITTER(frspx, 0xFC000018, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- Round_single(frB)
// TODO(benvanik): pull from FPSCR[RN]
RoundMode round_mode = ROUND_TO_ZERO;
Value* v = f.Convert(f.LoadFPR(i.X.RB), FLOAT32_TYPE, round_mode);
v = f.Convert(v, FLOAT64_TYPE);
f.StoreFPR(i.X.RT, v);
// f.UpdateFPRF(v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
// Floating-point compare (A-11)
int InstrEmit_fcmpx_(PPCHIRBuilder& f, InstrData& i, bool ordered) {
// if (FRA) is a NaN or (FRB) is a NaN then
// c <- 0b0001
// else if (FRA) < (FRB) then
// c <- 0b1000
// else if (FRA) > (FRB) then
// c <- 0b0100
// else {
// c <- 0b0010
// }
// FPCC <- c
// CR[4*BF:4*BF+3] <- c
// if (FRA) is an SNaN or (FRB) is an SNaN then
// VXSNAN <- 1
// TODO(benvanik): update FPCC for mffsx/etc
// TODO(benvanik): update VXSNAN
const uint32_t crf = i.X.RT >> 2;
// f.UpdateFPRF(v);
f.UpdateCR(crf, f.LoadFPR(i.X.RA), f.LoadFPR(i.X.RB), false);
return 0;
}
XEEMITTER(fcmpo, 0xFC000040, X)(PPCHIRBuilder& f, InstrData& i) {
return InstrEmit_fcmpx_(f, i, true);
}
XEEMITTER(fcmpu, 0xFC000000, X)(PPCHIRBuilder& f, InstrData& i) {
return InstrEmit_fcmpx_(f, i, false);
}
// Floating-point status and control register (A
XEEMITTER(mcrfs, 0xFC000080, X)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mffsx, 0xFC00048E, X)(PPCHIRBuilder& f, InstrData& i) {
if (i.X.Rc) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
Value* v = f.Cast(f.LoadFPSCR(), FLOAT64_TYPE);
f.StoreFPR(i.X.RT, v);
return 0;
}
XEEMITTER(mtfsb0x, 0xFC00008C, X)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsb1x, 0xFC00004C, X)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
XEEMITTER(mtfsfx, 0xFC00058E, XFL)(PPCHIRBuilder& f, InstrData& i) {
if (i.XFL.Rc) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
if (i.XFL.L) {
// Move/shift.
XEINSTRNOTIMPLEMENTED();
return 1;
} else {
// Directly store.
// TODO(benvanik): use w/field mask to select bits.
i.XFL.W;
i.XFL.FM;
f.StoreFPSCR(f.Cast(f.LoadFPR(i.XFL.RB), INT64_TYPE));
}
return 0;
}
XEEMITTER(mtfsfix, 0xFC00010C, X)(PPCHIRBuilder& f, InstrData& i) {
XEINSTRNOTIMPLEMENTED();
return 1;
}
// Floating-point move (A-21)
XEEMITTER(fabsx, 0xFC000210, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- abs(frB)
Value* v = f.Abs(f.LoadFPR(i.X.RB));
f.StoreFPR(i.X.RT, v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fmrx, 0xFC000090, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- (frB)
Value* v = f.LoadFPR(i.X.RB);
f.StoreFPR(i.X.RT, v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnabsx, 0xFC000110, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- !abs(frB)
Value* v = f.Neg(f.Abs(f.LoadFPR(i.X.RB)));
f.StoreFPR(i.X.RT, v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
XEEMITTER(fnegx, 0xFC000050, X)(PPCHIRBuilder& f, InstrData& i) {
// frD <- ¬ frB[0] || frB[1-63]
Value* v = f.Neg(f.LoadFPR(i.X.RB));
f.StoreFPR(i.X.RT, v);
if (i.X.Rc) {
// e.update_cr_with_cond(1, v);
XEINSTRNOTIMPLEMENTED();
return 1;
}
return 0;
}
void RegisterEmitCategoryFPU() {
XEREGISTERINSTR(faddx, 0xFC00002A);
XEREGISTERINSTR(faddsx, 0xEC00002A);
XEREGISTERINSTR(fdivx, 0xFC000024);
XEREGISTERINSTR(fdivsx, 0xEC000024);
XEREGISTERINSTR(fmulx, 0xFC000032);
XEREGISTERINSTR(fmulsx, 0xEC000032);
XEREGISTERINSTR(fresx, 0xEC000030);
XEREGISTERINSTR(frsqrtex, 0xFC000034);
XEREGISTERINSTR(fsubx, 0xFC000028);
XEREGISTERINSTR(fsubsx, 0xEC000028);
XEREGISTERINSTR(fselx, 0xFC00002E);
XEREGISTERINSTR(fsqrtx, 0xFC00002C);
XEREGISTERINSTR(fsqrtsx, 0xEC00002C);
XEREGISTERINSTR(fmaddx, 0xFC00003A);
XEREGISTERINSTR(fmaddsx, 0xEC00003A);
XEREGISTERINSTR(fmsubx, 0xFC000038);
XEREGISTERINSTR(fmsubsx, 0xEC000038);
XEREGISTERINSTR(fnmaddx, 0xFC00003E);
XEREGISTERINSTR(fnmaddsx, 0xEC00003E);
XEREGISTERINSTR(fnmsubx, 0xFC00003C);
XEREGISTERINSTR(fnmsubsx, 0xEC00003C);
XEREGISTERINSTR(fcfidx, 0xFC00069C);
XEREGISTERINSTR(fctidx, 0xFC00065C);
XEREGISTERINSTR(fctidzx, 0xFC00065E);
XEREGISTERINSTR(fctiwx, 0xFC00001C);
XEREGISTERINSTR(fctiwzx, 0xFC00001E);
XEREGISTERINSTR(frspx, 0xFC000018);
XEREGISTERINSTR(fcmpo, 0xFC000040);
XEREGISTERINSTR(fcmpu, 0xFC000000);
XEREGISTERINSTR(mcrfs, 0xFC000080);
XEREGISTERINSTR(mffsx, 0xFC00048E);
XEREGISTERINSTR(mtfsb0x, 0xFC00008C);
XEREGISTERINSTR(mtfsb1x, 0xFC00004C);
XEREGISTERINSTR(mtfsfx, 0xFC00058E);
XEREGISTERINSTR(mtfsfix, 0xFC00010C);
XEREGISTERINSTR(fabsx, 0xFC000210);
XEREGISTERINSTR(fmrx, 0xFC000090);
XEREGISTERINSTR(fnabsx, 0xFC000110);
XEREGISTERINSTR(fnegx, 0xFC000050);
}
} // namespace frontend
} // namespace cpu
} // namespace xe
| 26.762393
| 79
| 0.627172
|
Parovozik
|
e7a232b376eb7f58d05f150495b52e63d05dda83
| 598
|
cpp
|
C++
|
checkersProgram/checkersProgram/checker.cpp
|
madv/CheckersProgram
|
b671efbdbe3d0e7442d347eb361bc35d771f78da
|
[
"MIT"
] | null | null | null |
checkersProgram/checkersProgram/checker.cpp
|
madv/CheckersProgram
|
b671efbdbe3d0e7442d347eb361bc35d771f78da
|
[
"MIT"
] | null | null | null |
checkersProgram/checkersProgram/checker.cpp
|
madv/CheckersProgram
|
b671efbdbe3d0e7442d347eb361bc35d771f78da
|
[
"MIT"
] | null | null | null |
#include "checker.h"
checker::checker(const char& color, const bool& isKing, int x, int y) : color(color), isKing(isKing), x(x), y(y)
{
}
checker::~checker()
{
}
void checker::setColor(char color)
{
this->color = color;
}
void checker::setKing(bool isKing)
{
this->isKing = isKing;
}
char checker::getColor() const
{
return this->color;
}
bool checker::getIsKing() const
{
return this->isKing;
}
int checker::getXLoc() const
{
return this->x;
}
int checker::getYLoc() const
{
return this->y;
}
void checker::setXLoc(int x)
{
this->x = x;
}
void checker::setYLoc(int y)
{
this->y = y;
}
| 13.590909
| 112
| 0.658863
|
madv
|
e7a640e4dd78ce1e0a3243720c6aeee719b78355
| 47
|
cpp
|
C++
|
core/Drawable.cpp
|
Xecutor/glider
|
811bfa91a76cb5dbc918a219681ad2e97cb553fa
|
[
"MIT"
] | null | null | null |
core/Drawable.cpp
|
Xecutor/glider
|
811bfa91a76cb5dbc918a219681ad2e97cb553fa
|
[
"MIT"
] | null | null | null |
core/Drawable.cpp
|
Xecutor/glider
|
811bfa91a76cb5dbc918a219681ad2e97cb553fa
|
[
"MIT"
] | null | null | null |
#include "Drawable.hpp"
namespace glider{
}
| 6.714286
| 23
| 0.702128
|
Xecutor
|
e7a9a1d731a4f54e845be7ee2cd398ad8dd3f193
| 1,753
|
cpp
|
C++
|
source/serialization/EpAttribute.cpp
|
soundandform/epigram
|
f4f560b405e529e84ffd4e8a0b1101bf57148b90
|
[
"MIT"
] | 3
|
2018-02-16T04:30:22.000Z
|
2021-03-26T02:06:51.000Z
|
source/serialization/EpAttribute.cpp
|
soundandform/epigram
|
f4f560b405e529e84ffd4e8a0b1101bf57148b90
|
[
"MIT"
] | null | null | null |
source/serialization/EpAttribute.cpp
|
soundandform/epigram
|
f4f560b405e529e84ffd4e8a0b1101bf57148b90
|
[
"MIT"
] | null | null | null |
//
// EpAttribute.cpp
// Tape
//
// Created by Steven Massey on 6/23/20.
// Copyright © 2020 Massey Plugins Inc. All rights reserved.
//
#include <string_view>
#include "EpAttribute.hpp"
u8 EpAttributes::GetTypeForName_ (const string & i_attributeName)
{
return m_attributes [i_attributeName].type;
}
string EpAttributes::GetHashAttributeName_ (u64 i_hash)
{
for (auto & i : m_attributes)
{
if (i.second.hash == i_hash)
return i.first;
}
return "<unregistered>";
}
void EpAttributes::RegisterAttribute_ (cstr_t i_name, u8 i_typeId, stringRef_t)
{
RegisterAttribute_ (i_name, i_typeId, (u64) 0);
}
void EpAttributes::RegisterAttribute_ (cstr_t i_name, u8 i_typeId, u64 i_hash)
{
u8 type = m_attributes [i_name].type;
if (type)
{
d_jdAssert (type == i_typeId, "attribute type collision"); // this should never happen, cause there'd be a class name collission first.
}
// cout << "register: " << std::hex << i_hash << " " << i_name << endl;
m_attributes [i_name] = { i_hash, i_typeId };
}
void EpAttributes::Dump_ ()
{
for (auto i : m_attributes)
{
cout << i.second.type << ": ";
cout << i.first;
if (i.second.hash)
cout << " (hash: 0x" << std::hex << i.second.hash << std::dec << ")";
cout << endl;
}
}
//----------------------------------------------------------------------------------------------------------------------------------------
EpHash32::EpHash32 ()
{
}
// EpHash32 (cstr_t i_name) : m_key (CityHash32 (i_name, strlen (i_name))) {}
EpHash32::EpHash32 (cstr_t i_name)
:
m_key ((u32) hash <string_view> () (string_view (i_name, strlen (i_name))))
{
}
EpHash64::EpHash64 (cstr_t i_name) : m_key (std::hash <std::string_view> () (std::string_view (i_name, strlen (i_name)))) {}
| 22.766234
| 138
| 0.6081
|
soundandform
|
e7aab713ad1ba20154560e68f28536dfec1fe541
| 6,186
|
cpp
|
C++
|
cvs/objects/target_finder/source/target_factory.cpp
|
cmcormack/gcam-core
|
ccbe826dbfeb9ed85472977aac6d36dbbf763a23
|
[
"ECL-2.0"
] | 157
|
2016-10-13T17:44:11.000Z
|
2022-03-30T09:34:50.000Z
|
cvs/objects/target_finder/source/target_factory.cpp
|
cmcormack/gcam-core
|
ccbe826dbfeb9ed85472977aac6d36dbbf763a23
|
[
"ECL-2.0"
] | 190
|
2016-10-13T20:19:10.000Z
|
2022-03-25T19:17:05.000Z
|
cvs/objects/target_finder/source/target_factory.cpp
|
cmcormack/gcam-core
|
ccbe826dbfeb9ed85472977aac6d36dbbf763a23
|
[
"ECL-2.0"
] | 95
|
2016-10-13T17:44:44.000Z
|
2022-03-28T02:10:52.000Z
|
/*
* LEGAL NOTICE
* This computer software was prepared by Battelle Memorial Institute,
* hereinafter the Contractor, under Contract No. DE-AC05-76RL0 1830
* with the Department of Energy (DOE). NEITHER THE GOVERNMENT NOR THE
* CONTRACTOR MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY
* LIABILITY FOR THE USE OF THIS SOFTWARE. This notice including this
* sentence must appear on any copies of this computer software.
*
* EXPORT CONTROL
* User agrees that the Software will not be shipped, transferred or
* exported into any country or used in any manner prohibited by the
* United States Export Administration Act or any other applicable
* export laws, restrictions or regulations (collectively the "Export Laws").
* Export of the Software may require some form of license or other
* authority from the U.S. Government, and failure to obtain such
* export control license may result in criminal liability under
* U.S. laws. In addition, if the Software is identified as export controlled
* items under the Export Laws, User represents and warrants that User
* is not a citizen, or otherwise located within, an embargoed nation
* (including without limitation Iran, Syria, Sudan, Cuba, and North Korea)
* and that User is not otherwise prohibited
* under the Export Laws from receiving the Software.
*
* Copyright 2011 Battelle Memorial Institute. All Rights Reserved.
* Distributed as open-source under the terms of the Educational Community
* License version 2.0 (ECL 2.0). http://www.opensource.org/licenses/ecl2.php
*
* For further details, see: http://www.globalchange.umd.edu/models/gcam/
*
*/
/*!
* \file target_factory.cpp
* \ingroup Objects
* \brief TargetFactory source file.
* \author Josh Lurz
*/
#include "util/base/include/definitions.h"
#include <string>
#include <cassert>
#include "target_finder/include/target_factory.h"
#include "util/logger/include/ilogger.h"
// Add new types here.
#include "target_finder/include/concentration_target.h"
#include "target_finder/include/forcing_target.h"
#include "target_finder/include/rcp_forcing_target.h"
#include "target_finder/include/temperature_target.h"
#include "target_finder/include/emissions_stabalization_target.h"
#include "target_finder/include/kyoto_forcing_target.h"
#include "target_finder/include/cumulative_emissions_target.h"
using namespace std;
/*! \brief Returns whether the requested type is a type the factory knows how to
* create.
* \param aType Type to determine if the factory can create.
* \return Whether the factory can create the type.
*/
bool TargetFactory::isOfType( const string& aType ) {
// Search the list of known types.
return ( ( aType == ConcentrationTarget::getXMLNameStatic() )
|| ( aType == ForcingTarget::getXMLNameStatic() )
|| ( aType == RCPForcingTarget::getXMLNameStatic() )
|| ( aType == TemperatureTarget::getXMLNameStatic() )
|| ( aType == KyotoForcingTarget::getXMLNameStatic() )
|| ( aType == CumulativeEmissionsTarget::getXMLNameStatic() )
|| ( aType == EmissionsStabalizationTarget::getXMLNameStatic() ) );
}
/*!
* \brief Return a new instance of a component of the requested type.
* \param aType Type of ITarget to return.
* \param aClimateModel Scenario's climate model.
* \param aTargetValue The target value.
* \param aFirstTaxYear The first year in which the target could be checked.
* \return A newly created ITarget wrapped in an auto_ptr. The pointer
* is null if the type is unknown.
*/
auto_ptr<ITarget> TargetFactory::create( const string& aType,
const IClimateModel* aClimateModel,
double aTargetValue,
int aFirstTaxYear )
{
// Search the list of known types.
if( aType == ConcentrationTarget::getXMLNameStatic() ) {
return auto_ptr<ITarget>( new ConcentrationTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == ForcingTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new ForcingTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == RCPForcingTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new RCPForcingTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == TemperatureTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new TemperatureTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == KyotoForcingTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new KyotoForcingTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == CumulativeEmissionsTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new CumulativeEmissionsTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
if( aType == EmissionsStabalizationTarget::getXMLNameStatic() ){
return auto_ptr<ITarget>( new EmissionsStabalizationTarget( aClimateModel,
aTargetValue,
aFirstTaxYear ) );
}
// Make sure this create is in sync with isOfType.
assert( !isOfType( aType ) );
// Unknown type.
ILogger& mainLog = ILogger::getLogger( "main_log" );
mainLog.setLevel( ILogger::ERROR );
mainLog << "Could not create Target of type " << aType << "." << endl;
return auto_ptr<ITarget>();
}
| 45.485294
| 86
| 0.622373
|
cmcormack
|
e7aee99a19c3e594eb93e9aef69b4c41d41fe0b9
| 151
|
cpp
|
C++
|
src/src/XEngine/Components/SpawnComponent.cpp
|
devxkh/FrankE
|
72faca02759b54aaec842831f3c7a051e7cf5335
|
[
"MIT"
] | 11
|
2017-01-17T15:02:25.000Z
|
2020-11-27T16:54:42.000Z
|
src/src/XEngine/Components/SpawnComponent.cpp
|
devxkh/FrankE
|
72faca02759b54aaec842831f3c7a051e7cf5335
|
[
"MIT"
] | 9
|
2016-10-23T20:15:38.000Z
|
2018-02-06T11:23:17.000Z
|
src/src/XEngine/Components/SpawnComponent.cpp
|
devxkh/FrankE
|
72faca02759b54aaec842831f3c7a051e7cf5335
|
[
"MIT"
] | 2
|
2019-08-29T10:23:51.000Z
|
2020-04-03T06:08:34.000Z
|
#include <XEngine/Components/SpawnComponent.hpp>
namespace XE
{
SpawnComponent::SpawnComponent()
: group(0)
, spawnPointId(0)
{
}
} // ns XE
| 11.615385
| 48
| 0.682119
|
devxkh
|
e7b360ab160b9b751a5d1e68f47fd9cd95e23e58
| 1,669
|
hpp
|
C++
|
generator/list.hpp
|
kindone/cppproptest
|
db3cace33af7914d6d2b65945baa5554da281725
|
[
"MIT"
] | 1
|
2021-06-19T05:40:33.000Z
|
2021-06-19T05:40:33.000Z
|
generator/list.hpp
|
kindone/cppproptest
|
db3cace33af7914d6d2b65945baa5554da281725
|
[
"MIT"
] | null | null | null |
generator/list.hpp
|
kindone/cppproptest
|
db3cace33af7914d6d2b65945baa5554da281725
|
[
"MIT"
] | null | null | null |
#pragma once
#include "../gen.hpp"
#include "../Random.hpp"
#include "../util/printing.hpp"
#include "../shrinker/listlike.hpp"
#include "util.hpp"
#include "../util/std.hpp"
namespace proptest {
template <typename T>
class PROPTEST_API Arbi<list<T>> final : public ArbiContainer<list<T>> {
public:
using List = list<T>;
using ArbiContainer<List>::minSize;
using ArbiContainer<List>::maxSize;
static size_t defaultMinSize;
static size_t defaultMaxSize;
Arbi() : ArbiContainer<List>(defaultMinSize, defaultMaxSize), elemGen(Arbi<T>()) {}
Arbi(const Arbi<T>& _elemGen)
: ArbiContainer<List>(defaultMinSize, defaultMaxSize),
elemGen([_elemGen](Random& rand) -> Shrinkable<T> { return _elemGen(rand); })
{
}
Arbi(GenFunction<T> _elemGen) : ArbiContainer<List>(defaultMinSize, defaultMaxSize), elemGen(_elemGen) {}
using vector_t = vector<Shrinkable<T>>;
using shrinkable_t = Shrinkable<vector_t>;
using stream_t = Stream<shrinkable_t>;
using e_stream_t = Stream<Shrinkable<T>>;
Shrinkable<list<T>> operator()(Random& rand) override
{
size_t size = rand.getRandomSize(minSize, maxSize + 1);
shared_ptr<vector_t> shrinkVec = util::make_shared<vector_t>();
shrinkVec->reserve(size);
for (size_t i = 0; i < size; i++)
shrinkVec->push_back(elemGen(rand));
return shrinkListLike<list, T>(shrinkVec, minSize);
}
// FIXME: turn to shared_ptr
GenFunction<T> elemGen;
};
template <typename T>
size_t Arbi<list<T>>::defaultMinSize = 0;
template <typename T>
size_t Arbi<list<T>>::defaultMaxSize = 200;
} // namespace proptest
| 29.803571
| 109
| 0.673457
|
kindone
|
e7b4027dbb3b186fae3b8eac56714ab036cf69dc
| 321
|
cpp
|
C++
|
ch03/ex3_25.cpp
|
yunongzhou/cppprimer
|
331cdc69f9063fca3466fda994a06de12387d0b3
|
[
"MIT"
] | 2
|
2018-08-22T15:04:17.000Z
|
2018-08-26T16:05:59.000Z
|
ch03/ex3_25.cpp
|
yunongzhou/cppprimer
|
331cdc69f9063fca3466fda994a06de12387d0b3
|
[
"MIT"
] | null | null | null |
ch03/ex3_25.cpp
|
yunongzhou/cppprimer
|
331cdc69f9063fca3466fda994a06de12387d0b3
|
[
"MIT"
] | null | null | null |
#include<iostream>
#include<vector>
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using Vector = vector<unsigned>;
int main(){
Vector score(11,0);
unsigned grade;
while(cin >> grade){
++(*(score.begin() + grade/10));
}
for(auto i:score) cout << i << endl;
return 0;
} // main
| 13.956522
| 38
| 0.619938
|
yunongzhou
|
e7b788bd461f209151b61cf5f52dd1ea7f50de69
| 974
|
cpp
|
C++
|
kalimat/Parser/parserexception.cpp
|
mobadarah/kalimat-lang
|
9eb6c64dd5380efaf863b619a506ebf000be7fd9
|
[
"Apache-2.0"
] | 6
|
2021-07-05T15:35:33.000Z
|
2022-03-25T21:21:43.000Z
|
kalimat/Parser/parserexception.cpp
|
anasawad/kalimat
|
830cbe9ddde13865bc1f77a2f74efd3dac3b58cc
|
[
"Apache-2.0"
] | null | null | null |
kalimat/Parser/parserexception.cpp
|
anasawad/kalimat
|
830cbe9ddde13865bc1f77a2f74efd3dac3b58cc
|
[
"Apache-2.0"
] | 1
|
2022-03-25T21:15:33.000Z
|
2022-03-25T21:15:33.000Z
|
#include "../Lexer/token.h"
#include "parserexception.h"
ParserException::ParserException(QString fileName, QString msg)
{
this->fileName = fileName;
message = msg;
hasPosInfo = false;
ErrType = -1;
}
ParserException::ParserException(QString fileName, Token pos, QString msg)
{
this->fileName = fileName;
if(pos.Type == TokenInvalid)
hasPosInfo = false;
else
hasPosInfo = true;
this->pos = pos;
message = QString("%5(%1,%2, pos=%3): %4")
.arg(pos.Line)
.arg(pos.Column)
.arg(pos.Pos)
.arg(msg)
.arg((fileName!="")?QFileInfo(fileName).fileName()+":" : "");
ErrType = -1;
}
ParserException::ParserException(QString fileName, Token pos, int type)
{
this->fileName = fileName;
if(pos.Type == TokenInvalid)
hasPosInfo = false;
else
hasPosInfo = true;
this->pos = pos;
ErrType = type;
}
| 24.974359
| 75
| 0.568789
|
mobadarah
|
e7b7db709e137c39e4fac6d2d4c394eb1d98e3d7
| 10,673
|
cc
|
C++
|
sparse_operation_kit/kit_cc/kit_cc_infra/src/embeddings/embedding_layer.cc
|
marsmiao/HugeCTR
|
c9ff359a69565200fcc0c7aae291d9c297bea70e
|
[
"Apache-2.0"
] | null | null | null |
sparse_operation_kit/kit_cc/kit_cc_infra/src/embeddings/embedding_layer.cc
|
marsmiao/HugeCTR
|
c9ff359a69565200fcc0c7aae291d9c297bea70e
|
[
"Apache-2.0"
] | null | null | null |
sparse_operation_kit/kit_cc/kit_cc_infra/src/embeddings/embedding_layer.cc
|
marsmiao/HugeCTR
|
c9ff359a69565200fcc0c7aae291d9c297bea70e
|
[
"Apache-2.0"
] | null | null | null |
/*
* Copyright (c) 2021, NVIDIA CORPORATION.
*
* 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 "embeddings/embedding_layer.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/variant_op_registry.h"
namespace SparseOperationKit {
EmbeddingLayer::EmbeddingLayer(std::shared_ptr<Dispatcher> input_dispatcher,
std::shared_ptr<EmbeddingLookuper> embedding_lookuper,
std::shared_ptr<Dispatcher> output_dispatcher,
ConstructionContext_t context)
: input_dispatcher_(input_dispatcher), embedding_lookuper_(embedding_lookuper),
output_dispatcher_(output_dispatcher), base_context_(context),
global_batch_size_(context->get_replica_batch_size() * context->get_resource_mgr()->get_global_gpu_count())
{}
std::shared_ptr<EmbeddingLayer> EmbeddingLayer::create(std::shared_ptr<Dispatcher> input_dispatcher,
std::shared_ptr<EmbeddingLookuper> embedding_lookuper,
std::shared_ptr<Dispatcher> output_dispatcher,
ConstructionContext_t context) {
return std::shared_ptr<EmbeddingLayer>(new EmbeddingLayer(input_dispatcher, embedding_lookuper,
output_dispatcher, context));
}
void EmbeddingLayer::allocate_forward_spaces() {
input_dispatcher_->AllocateForwardSpaces();
embedding_lookuper_->AllocateForwardSpaces();
output_dispatcher_->AllocateForwardSpaces();
}
void EmbeddingLayer::allocate_backward_spaces() {
input_dispatcher_->AllocateBackwardSpaces();
embedding_lookuper_->AllocateBackwardSpaces();
output_dispatcher_->AllocateBackwardSpaces();
}
void EmbeddingLayer::forward(const Context_t &replica_context, const bool training) {
// step 1 dispatch input to each GPU, Data-Parallel -> Model Parallel
input_dispatcher_->Forward(replica_context, training);
// step 2 do embedding lookup on each GPU independently
embedding_lookuper_->Forward(replica_context, training);
// step 3 dispatch embedding vector to each GPU, Model-Parallel -> Data-Parallel
output_dispatcher_->Forward(replica_context, training);
}
void EmbeddingLayer::backward(const Context_t &replica_context) {
// step 1 dispatch top_gradients to each GPU, Data-Parallel -> Model Parallel
output_dispatcher_->Backward(replica_context);
// step 2 do backward on each GPU independently
embedding_lookuper_->Backward(replica_context);
// step 3 dispatch input grads to each GPU, Model-Parallel -> Data Parallel
input_dispatcher_->Backward(replica_context);
}
void EmbeddingLayer::get_output_shape(std::vector<int64_t> &output_shape) const {
// dim-0 is replica_batch_size, which is already set by EmbeddingManager
output_shape.push_back(base_context_->get_slot_num());
output_shape.push_back(base_context_->get_param()->get_embedding_vec_size());
// check its rank
if (3 != output_shape.size())
throw std::runtime_error(ErrorBase + "For Sparse Embedding Layer, the output shape " +
"should be [replica_batch_size, slot_num, emb_vec_size]. " +
"But now its rank is " + std::to_string(output_shape.size()));
}
void EmbeddingLayer::get_grad_shape(const Context_t &replica_context, std::vector<int64_t> &grad_shape) const {
const auto replica_host_nnz = replica_context->input("replica_host_nnz");
grad_shape.push_back(static_cast<int64_t>(replica_host_nnz->GetPtrWithType<size_t>()[0]));
grad_shape.push_back(static_cast<int64_t>(base_context_->get_param()->get_embedding_vec_size()));
}
size_t EmbeddingLayer::get_global_batch_size() const {
return global_batch_size_;
}
size_t EmbeddingLayer::get_max_feature_num() const {
return base_context_->get_max_feature_num();
}
std::string EmbeddingLayer::get_var_name() const {
return base_context_->get_param()->get_var_name();
}
size_t EmbeddingLayer::get_max_vocabulary_size_per_gpu() const {
return base_context_->get_param()->get_max_vocabulary_size_per_gpu();
}
void EmbeddingLayer::dump_to_file(const std::string filepath) const {
input_dispatcher_->DumpToFile(filepath);
embedding_lookuper_->DumpToFile(filepath);
output_dispatcher_->DumpToFile(filepath);
}
void EmbeddingLayer::restore_from_file(const std::string filepath) {
input_dispatcher_->RestoreFromFile(filepath);
embedding_lookuper_->RestoreFromFile(filepath);
output_dispatcher_->RestoreFromFile(filepath);
}
void EmbeddingLayer::restore_params(const std::shared_ptr<Tensor> &keys,
const std::shared_ptr<Tensor> &embedding_values,
const size_t num_total_keys) {
// because the params is only used by embedding lookuper,
// so that delegate this job to embedding lookuper
embedding_lookuper_->restore_params(keys, embedding_values, num_total_keys);
}
bool EmbeddingLayer::save_params(const std::string filepath) const {
// because the params is only used by embedding lookuper,
// so that delegate this job to embedding lookuper
return embedding_lookuper_->save_params(filepath);
}
void EmbeddingLayer::load_embedding_values(const std::vector<std::shared_ptr<Tensor>>& tensor_list) {
input_dispatcher_->LoadEmbeddingValues(tensor_list);
embedding_lookuper_->LoadEmbeddingValues(tensor_list);
output_dispatcher_->LoadEmbeddingValues(tensor_list);
}
ConstructionContext_t EmbeddingLayer::base_context() const {
return base_context_;
}
DenseEmbeddingLayer::DenseEmbeddingLayer(std::shared_ptr<Dispatcher> input_dispatcher,
std::shared_ptr<EmbeddingLookuper> embedding_lookuper,
std::shared_ptr<Dispatcher> output_dispatcher,
ConstructionContext_t context)
: EmbeddingLayer(input_dispatcher, embedding_lookuper, output_dispatcher, context)
{}
std::shared_ptr<DenseEmbeddingLayer> DenseEmbeddingLayer::create(std::shared_ptr<Dispatcher> input_dispatcher,
std::shared_ptr<EmbeddingLookuper> embedding_lookuper,
std::shared_ptr<Dispatcher> output_dispatcher,
ConstructionContext_t context) {
return std::shared_ptr<DenseEmbeddingLayer>(new DenseEmbeddingLayer(
input_dispatcher, embedding_lookuper, output_dispatcher, context));
}
void DenseEmbeddingLayer::get_output_shape(std::vector<int64_t>& output_shape) const {
// dim-0 is replica_batch_size, which is already set by EmbeddingManager
output_shape.push_back(base_context()->get_slot_num());
output_shape.push_back(base_context()->get_nnz_per_slot());
output_shape.push_back(base_context()->get_param()->get_embedding_vec_size());
// check its rank
if (4 != output_shape.size())
throw std::runtime_error(ErrorBase + "For Dense Embedding Layer, the output shape " +
"should be [replica_batch_size, slot_num, nnz_per_slot, emb_vec_size]. " +
"But now its rank is " + std::to_string(output_shape.size()));
}
size_t DenseEmbeddingLayer::get_max_feature_num() const {
return base_context()->get_slot_num() * base_context()->get_nnz_per_slot();
}
class EmbeddingVariantWrapper {
public:
EmbeddingVariantWrapper() : embedding_(nullptr) {}
explicit EmbeddingVariantWrapper(const std::shared_ptr<EmbeddingLayer> emb) : embedding_(emb) {}
EmbeddingVariantWrapper(const EmbeddingVariantWrapper& other): embedding_(other.embedding_) {}
EmbeddingVariantWrapper& operator=(EmbeddingVariantWrapper&& other) {
if (&other == this) return *this;
embedding_ = other.embedding_;
return *this;
}
EmbeddingVariantWrapper& operator=(const EmbeddingVariantWrapper& other) = delete;
std::shared_ptr<EmbeddingLayer> get() const { return embedding_; }
~EmbeddingVariantWrapper() = default;
tensorflow::string TypeName() const { return "EmbeddingPlugin::EmbeddingVariantWrapper"; }
void Encode(tensorflow::VariantTensorData* data) const {
LOG(ERROR) << "The Encode() method is not implemented for "
"EmbeddingVariantWrapper objects.";
}
bool Decode(const tensorflow::VariantTensorData& data) {
LOG(ERROR) << "The Decode() method is not implemented for "
"EmbeddingVariantWrapper objects.";
return false;
}
private:
std::shared_ptr<EmbeddingLayer> embedding_;
};
void GetEmbeddingFromVariantTensor(const tensorflow::Tensor* tensor,
std::shared_ptr<EmbeddingLayer>& out_emb) {
if (!(tensor->dtype() == tensorflow::DT_VARIANT &&
tensorflow::TensorShapeUtils::IsScalar(tensor->shape()))) {
throw std::runtime_error(ErrorBase + "Embedding tensor must be a scalar of dtype DT_VARIANT.");
}
const tensorflow::Variant& variant = tensor->scalar<tensorflow::Variant>()();
const EmbeddingVariantWrapper* wrapper = variant.get<EmbeddingVariantWrapper>();
if (nullptr == wrapper) throw std::runtime_error(ErrorBase + "Tensor must be a EmbeddingPlugin::Embedding object.");
out_emb = wrapper->get();
if (!out_emb) throw std::runtime_error(ErrorBase + "read empty embedding object.");
}
void StoreEmbeddingInVariantTensor(const std::shared_ptr<EmbeddingLayer>& emb,
tensorflow::Tensor* tensor) {
if (!(tensor->dtype() == tensorflow::DT_VARIANT &&
tensorflow::TensorShapeUtils::IsScalar(tensor->shape()))) {
throw std::runtime_error(ErrorBase + "Embedding tensor must be a scalar of dtype DT_VARIANT.");
}
tensor->scalar<tensorflow::Variant>()() = EmbeddingVariantWrapper(emb);
}
} // namespace SparseOperationKit
| 45.033755
| 120
| 0.696805
|
marsmiao
|
e7baf270c19223d17fd5cefdf85648a50b45b32b
| 325
|
cpp
|
C++
|
test/main.cpp
|
Sharma117555448/Robot_Contoller-1
|
2656345bd24b34153ea1f5751d99438e199e8546
|
[
"MIT"
] | 1
|
2022-03-25T13:42:01.000Z
|
2022-03-25T13:42:01.000Z
|
test/main.cpp
|
Sharma117555448/Robot_Contoller-1
|
2656345bd24b34153ea1f5751d99438e199e8546
|
[
"MIT"
] | null | null | null |
test/main.cpp
|
Sharma117555448/Robot_Contoller-1
|
2656345bd24b34153ea1f5751d99438e199e8546
|
[
"MIT"
] | 1
|
2021-10-06T19:48:46.000Z
|
2021-10-06T19:48:46.000Z
|
/**
* @file main.cpp
* @authors Vivek Sood and Charu Sharma
* @brief primary source file
* @date 2021-10-16
* @copyright Copyright (c) 2021
*
* ENPM808X Midterm - Phase 0 Proposal
*
*/
#include <gtest/gtest.h>
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 18.055556
| 41
| 0.661538
|
Sharma117555448
|
e7c0f769c870cef1dee6a63a884e943e9cff3765
| 5,774
|
cpp
|
C++
|
blingfireclient.library/src/FAWftConfKeeper.cpp
|
ameyac-msft/BlingFire
|
02d2218344a3b67d50f84b19e92103d79a99ae5b
|
[
"MIT"
] | null | null | null |
blingfireclient.library/src/FAWftConfKeeper.cpp
|
ameyac-msft/BlingFire
|
02d2218344a3b67d50f84b19e92103d79a99ae5b
|
[
"MIT"
] | null | null | null |
blingfireclient.library/src/FAWftConfKeeper.cpp
|
ameyac-msft/BlingFire
|
02d2218344a3b67d50f84b19e92103d79a99ae5b
|
[
"MIT"
] | null | null | null |
/**
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License.
*/
#include "blingfire-client_src_pch.h"
#include "FAConfig.h"
#include "FAWftConfKeeper.h"
#include "FAFsmConst.h"
#include "FALDB.h"
#include "FARSDfa_pack_triv.h"
#include "FAState2Ows_pack_triv.h"
#include "FAMultiMap_pack.h"
#include "FAMultiMap_pack_mph.h"
#include "FAGetIWs_pack_triv.h"
#include "FAMultiMap_pack_fixed.h"
#include "FAUtils_cl.h"
FAWftConfKeeper::FAWftConfKeeper () :
m_pLDB (NULL),
m_pDfa (NULL),
m_pState2Ows (NULL),
m_pActsA (NULL),
m_pActs_triv (NULL),
m_pActs_mph (NULL),
m_pIws (NULL),
m_NoTrUse (false),
m_DictMode (false),
m_IgnoreCase (false),
m_UseNfst (false),
m_pCharMap (NULL)
{}
FAWftConfKeeper::~FAWftConfKeeper ()
{
FAWftConfKeeper::Clear ();
}
void FAWftConfKeeper::Initialize (const FALDB * pLDB, const int * pValues, const int Size)
{
LogAssert (pLDB);
LogAssert (pValues || 0 >= Size);
m_pLDB = pLDB;
FAWftConfKeeper::Clear ();
int MapMode = FAFsmConst::MODE_PACK_TRIV;
for (int i = 0; i < Size; ++i) {
const int Param = pValues [i];
switch (Param) {
case FAFsmConst::PARAM_NO_TR:
{
m_NoTrUse = true;
break;
}
case FAFsmConst::PARAM_IGNORE_CASE:
{
m_IgnoreCase = true;
break;
}
case FAFsmConst::PARAM_USE_NFST:
{
m_UseNfst = true;
break;
}
case FAFsmConst::PARAM_DICT_MODE:
{
m_DictMode = true;
break;
}
case FAFsmConst::PARAM_FSM:
{
const int DumpNum = pValues [++i];
const unsigned char * pDump = m_pLDB->GetDump (DumpNum);
LogAssert (pDump);
if (!m_pDfa) {
m_pDfa = NEW FARSDfa_pack_triv;
LogAssert (m_pDfa);
}
m_pDfa->SetImage (pDump);
if (!m_UseNfst) {
if (!m_pState2Ows) {
m_pState2Ows = NEW FAState2Ows_pack_triv;
LogAssert (m_pState2Ows);
}
m_pState2Ows->SetImage (pDump);
} else {
if (!m_pIws) {
m_pIws = NEW FAGetIWs_pack_triv;
LogAssert (m_pIws);
}
m_pIws->SetImage (pDump);
}
break;
}
case FAFsmConst::PARAM_MAP_MODE:
{
MapMode = pValues [++i];
LogAssert (FAFsmConst::MODE_PACK_TRIV == MapMode || \
FAFsmConst::MODE_PACK_MPH == MapMode);
LogAssert (MapMode == FAFsmConst::MODE_PACK_TRIV || !m_UseNfst);
break;
}
case FAFsmConst::PARAM_CHARMAP:
{
const int DumpNum = pValues [++i];
const unsigned char * pDump = m_pLDB->GetDump (DumpNum);
LogAssert (pDump);
if (!m_pCharMap) {
m_pCharMap = NEW FAMultiMap_pack_fixed;
LogAssert (m_pCharMap);
}
m_pCharMap->SetImage (pDump);
break;
}
case FAFsmConst::PARAM_ACTS:
{
const int DumpNum = pValues [++i];
const unsigned char * pDump = m_pLDB->GetDump (DumpNum);
LogAssert (pDump);
if (FAFsmConst::MODE_PACK_TRIV == MapMode) {
if (!m_pActs_triv) {
m_pActs_triv = NEW FAMultiMap_pack;
LogAssert (m_pActs_triv);
}
m_pActs_triv->SetImage (pDump);
m_pActsA = m_pActs_triv;
} else if (FAFsmConst::MODE_PACK_MPH == MapMode) {
if (!m_pActs_mph) {
m_pActs_mph = NEW FAMultiMap_pack_mph;
LogAssert (m_pActs_mph);
}
m_pActs_mph->SetImage (pDump);
m_pActsA = m_pActs_mph;
}
break;
}
default:
LogAssert (false);
} // of switch (Param) ...
}
}
void FAWftConfKeeper::Clear ()
{
if (m_pDfa) {
delete m_pDfa;
m_pDfa = NULL;
}
if (m_pState2Ows) {
delete m_pState2Ows;
m_pState2Ows = NULL;
}
if (m_pActs_triv) {
delete m_pActs_triv;
m_pActs_triv = NULL;
}
if (m_pActs_mph) {
delete m_pActs_mph;
m_pActs_mph = NULL;
}
if (m_pIws) {
delete m_pIws;
m_pIws = NULL;
}
if (m_pCharMap) {
delete m_pCharMap;
m_pCharMap = NULL;
}
m_pActsA = NULL;
m_NoTrUse = false;
m_IgnoreCase = false;
m_DictMode = false;
m_UseNfst = false;
}
const FARSDfaCA * FAWftConfKeeper::GetRsDfa () const
{
return m_pDfa;
}
const FAState2OwsCA * FAWftConfKeeper::GetState2Ows () const
{
return m_pState2Ows;
}
const FAMultiMapCA * FAWftConfKeeper::GetActs () const
{
return m_pActsA;
}
const bool FAWftConfKeeper::GetNoTrUse () const
{
return m_NoTrUse;
}
const bool FAWftConfKeeper::GetDictMode () const
{
return m_DictMode;
}
const bool FAWftConfKeeper::GetIgnoreCase () const
{
return m_IgnoreCase;
}
const FAGetIWsCA * FAWftConfKeeper::GetIws () const
{
return m_pIws;
}
const bool FAWftConfKeeper::GetUseNfst () const
{
return m_UseNfst;
}
const FAMultiMapCA * FAWftConfKeeper::GetCharMap () const
{
return m_pCharMap;
}
| 23.376518
| 91
| 0.520783
|
ameyac-msft
|
b10e05d29d08ba326046ea0d635cd56fedada92d
| 3,572
|
cpp
|
C++
|
src/event/event_emitter.cpp
|
hexoctal/zenith
|
eeef065ed62f35723da87c8e73a6716e50d34060
|
[
"MIT"
] | 2
|
2021-03-18T16:25:04.000Z
|
2021-11-13T00:29:27.000Z
|
src/event/event_emitter.cpp
|
hexoctal/zenith
|
eeef065ed62f35723da87c8e73a6716e50d34060
|
[
"MIT"
] | null | null | null |
src/event/event_emitter.cpp
|
hexoctal/zenith
|
eeef065ed62f35723da87c8e73a6716e50d34060
|
[
"MIT"
] | 1
|
2021-11-13T00:29:30.000Z
|
2021-11-13T00:29:30.000Z
|
/**
* @file
* @author __AUTHOR_NAME__ <mail@host.com>
* @copyright 2021 __COMPANY_LTD__
* @license <a href="https://opensource.org/licenses/MIT">MIT License</a>
*/
#include "event_emitter.hpp"
namespace Zen {
std::vector<std::string> EventEmitter::getEventNames (Entity entity_)
{
auto iterator_ = eventMap.find(entity_);
if (iterator_ == eventMap.end())
return {};
std::vector<std::string> names_;
for (const auto& it_ : eventMap[entity_])
names_.emplace_back(it_.first);
return names_;
}
int EventEmitter::getListenerCount (Entity entity_, std::string event_)
{
auto iteratorE_ = eventMap.find(entity_);
if (iteratorE_ == eventMap.end())
return 0;
auto iterator_ = eventMap[entity_].find(event_);
int count_ = 0;
if (iterator_ != eventMap[entity_].end())
count_ = iterator_->second.size();
return count_;
}
int EventEmitter::getListenerCount (std::string event_)
{
return getListenerCount(entt::null, event_);
}
std::vector<ListenerBase*> EventEmitter::getListeners (Entity entity_, std::string event_)
{
auto iteratorE_ = eventMap.find(entity_);
if (iteratorE_ == eventMap.end())
return {};
std::vector<ListenerBase*> vec_;
// Check if event exists
auto iterator_ = eventMap[entity_].find(event_);
if (iterator_ != eventMap[entity_].end())
{
for (auto& l_ : iterator_->second)
vec_.push_back(l_.get());
}
return vec_;
}
std::vector<ListenerBase*> EventEmitter::getListeners (std::string event_)
{
return getListeners(entt::null, event_);
}
void EventEmitter::removeListener (ListenerBase* listener_)
{
if (listener_ == nullptr)
return;
auto entity_ = listener_->entity;
auto iteratorE_ = eventMap.find(entity_);
if (iteratorE_ == eventMap.end())
return;
// Check if event exists
auto iterator_ = eventMap[entity_].find(listener_->event);
if (iterator_ != eventMap[entity_].end())
{
// Find listener
for (size_t i_ = 0; i_ < iterator_->second.size(); i_++)
{
if (listener_ == iterator_->second[i_].get())
{
iterator_->second.erase(iterator_->second.begin() + i_);
listener_ = nullptr;
break;
}
}
}
// Remove the event if no more listeners remain
if (iterator_->second.empty())
eventMap[entity_].erase(iterator_);
// Remove the entity if no more events remain
if (iteratorE_->second.empty())
eventMap.erase(iteratorE_);
}
void EventEmitter::off (ListenerBase* listener_)
{
removeListener(listener_);
}
void EventEmitter::removeAllListeners (Entity entity_, std::vector<std::string> eventNames_)
{
auto iteratorE_ = eventMap.find(entity_);
if (iteratorE_ == eventMap.end())
return;
// Check if events were sent
if (eventNames_.empty())
{
// If no event was sent, remove all events and their listeners
eventMap[entity_].clear();
}
else
{
// If events were sent, remove them with their listeners
for (auto& event_ : eventNames_)
{
// Check if event exists
auto iterator_ = eventMap[entity_].find(event_);
if (iterator_ != eventMap[entity_].end())
eventMap[entity_].erase(iterator_);
}
}
}
void EventEmitter::removeAllListeners (std::vector<std::string> eventNames_)
{
removeAllListeners(entt::null, eventNames_);
}
void EventEmitter::removeAllListeners (Entity entity_, std::string eventName_)
{
std::vector<std::string> events_ {eventName_};
removeAllListeners(entity_, events_);
}
void EventEmitter::removeAllListeners (std::string eventName_)
{
std::vector<std::string> events_ {eventName_};
removeAllListeners(entt::null, events_);
}
void EventEmitter::clear ()
{
eventMap.clear();
}
} // namespace Zen
| 22.465409
| 92
| 0.707167
|
hexoctal
|
b1113c895c52c9ea12d0332e7e26c57b72f5c320
| 936
|
cpp
|
C++
|
connect_nodes_at_same_level.cpp
|
Gauawa12/GFG-codes
|
c790efb783c463187dcfce4b7155d9f86227dbed
|
[
"MIT"
] | null | null | null |
connect_nodes_at_same_level.cpp
|
Gauawa12/GFG-codes
|
c790efb783c463187dcfce4b7155d9f86227dbed
|
[
"MIT"
] | null | null | null |
connect_nodes_at_same_level.cpp
|
Gauawa12/GFG-codes
|
c790efb783c463187dcfce4b7155d9f86227dbed
|
[
"MIT"
] | null | null | null |
void connect(Node *p)
{
queue<Node*>q;
q.push(p);
while(!q.empty())
{
int s=q.size();
while(s>=1)
{
if(s==1)
{
Node* t=q.front();
q.pop();
if(t->left)
{
q.push(t->left);
}
if(t->right)
{
q.push(t->right);
}
s--;
}
else
{
Node* t=q.front();
q.pop();
Node* t1=q.front();
t->nextRight=t1;
if(t->left)
{
q.push(t->left);
}
if(t->right)
{
q.push(t->right);
}
s--;
}
}
}
}
| 19.5
| 36
| 0.208333
|
Gauawa12
|
b1118c1008c7ac10f8f94b2174409eed8c829373
| 386
|
cpp
|
C++
|
templates/others/zeller.cpp
|
st1vdy/Algorithm-Library
|
7fdab3190afbb7076e95650bce712857107c80ef
|
[
"MIT"
] | 4
|
2021-11-05T08:57:30.000Z
|
2022-03-23T06:45:38.000Z
|
templates/others/zeller.cpp
|
st1vdy/Algorithm-Library
|
7fdab3190afbb7076e95650bce712857107c80ef
|
[
"MIT"
] | null | null | null |
templates/others/zeller.cpp
|
st1vdy/Algorithm-Library
|
7fdab3190afbb7076e95650bce712857107c80ef
|
[
"MIT"
] | null | null | null |
int zeller(int y, int m, int d) { // 蔡勒公式 返回星期几
if (m <= 2) y--, m += 12;
int c = y / 100; y %= 100;
int w = ((c >> 2) - (c << 1) + y + (y >> 2) +
(13 * (m + 1) / 5) + d - 1) % 7;
if (w < 0) w += 7;
return (w);
}
int getId(int y, int m, int d) { // 返回到公元1年1月1日的天数
if (m < 3) { y--; m += 12; }
return 365 * y + y / 4 - y / 100 + y / 400 +
(153 * (m - 3) + 2) / 5 + d - 307;
}
| 29.692308
| 50
| 0.401554
|
st1vdy
|
b111a24146b20b1b91f6f267045611d2c5b15212
| 1,049
|
cpp
|
C++
|
coordinate.cpp
|
nyczbrandon/RushHour
|
decb78ae430314a07f2cde5673e36a7b6ec9976a
|
[
"Xnet",
"X11",
"CECILL-B"
] | 1
|
2018-02-11T01:33:53.000Z
|
2018-02-11T01:33:53.000Z
|
coordinate.cpp
|
nyczbrandon/RushHour
|
decb78ae430314a07f2cde5673e36a7b6ec9976a
|
[
"Xnet",
"X11",
"CECILL-B"
] | null | null | null |
coordinate.cpp
|
nyczbrandon/RushHour
|
decb78ae430314a07f2cde5673e36a7b6ec9976a
|
[
"Xnet",
"X11",
"CECILL-B"
] | null | null | null |
#include "coordinate.hh"
Coordinate::Coordinate(char r, int c)
{
row = r;
col = c;
}
char Coordinate::getRow()
{
return row;
}
int Coordinate::getColumn()
{
return col;
}
Coordinate Coordinate::getLeft()
{
return Coordinate(row, col - 1);
}
Coordinate Coordinate::getRight()
{
return Coordinate(row, col + 1);
}
Coordinate Coordinate::getUp()
{
return Coordinate(row - 1, col);
}
Coordinate Coordinate::getDown()
{
return Coordinate(row + 1, col);
}
Coordinate Coordinate::getLeft(int i)
{
return Coordinate(row, col - i);
}
Coordinate Coordinate::getRight(int i)
{
return Coordinate(row, col + i);
}
Coordinate Coordinate::getUp(int i)
{
return Coordinate(row - i, col);
}
Coordinate Coordinate::getDown(int i)
{
return Coordinate(row + i, col);
}
bool Coordinate::isSameCoordinate(Coordinate c)
{
if (row == c.row && col == c.col)
return true;
return false;
}
bool Coordinate::isGoal()
{
if (row == 'C' && col == 5)
return true;
return false;
}
| 14.774648
| 48
| 0.628217
|
nyczbrandon
|
b111e59f63297c0c9ef425fe2e9b59a3c4d2ceae
| 399
|
cc
|
C++
|
leetcode/powx-n.cc
|
Waywrong/leetcode-solution
|
55115aeab4040f5ff84bdce6ffcfe4a98f879616
|
[
"MIT"
] | null | null | null |
leetcode/powx-n.cc
|
Waywrong/leetcode-solution
|
55115aeab4040f5ff84bdce6ffcfe4a98f879616
|
[
"MIT"
] | null | null | null |
leetcode/powx-n.cc
|
Waywrong/leetcode-solution
|
55115aeab4040f5ff84bdce6ffcfe4a98f879616
|
[
"MIT"
] | null | null | null |
// Pow(x,n)
class Solution {
public:
double myPow(double x, int n) {
if (x == 0) return 0;
if (n == 0) return 1;
if (n < 0) {
n = abs(n);
x = 1 / x;
}
double t = myPow(x, n/2);
double res;
if (n % 2)
res = t * t * x;
else
res = t * t;
return !isinf(res) ? res : 0;
}
};
| 19.95
| 37
| 0.353383
|
Waywrong
|
b11225f85adcbb6befe38f5161391a8f99f2951f
| 6,104
|
cpp
|
C++
|
Source/Foundation/bsfCore/Renderer/BsSkybox.cpp
|
hhyyrylainen/bsf
|
b8c1f88d9e5a236a8623a39d0fb91d65995a7660
|
[
"MIT"
] | null | null | null |
Source/Foundation/bsfCore/Renderer/BsSkybox.cpp
|
hhyyrylainen/bsf
|
b8c1f88d9e5a236a8623a39d0fb91d65995a7660
|
[
"MIT"
] | null | null | null |
Source/Foundation/bsfCore/Renderer/BsSkybox.cpp
|
hhyyrylainen/bsf
|
b8c1f88d9e5a236a8623a39d0fb91d65995a7660
|
[
"MIT"
] | null | null | null |
//************************************ bs::framework - Copyright 2018 Marko Pintera **************************************//
//*********** Licensed under the MIT license. See LICENSE.md for full terms. This notice is not to be removed. ***********//
#include "Renderer/BsSkybox.h"
#include "Private/RTTI/BsSkyboxRTTI.h"
#include "Scene/BsSceneObject.h"
#include "Image/BsTexture.h"
#include "Renderer/BsRenderer.h"
#include "Utility/BsUUID.h"
#include "Renderer/BsIBLUtility.h"
#include "CoreThread/BsCoreObjectSync.h"
namespace bs
{
template <bool Core>
template <class P>
void TSkybox<Core>::rttiEnumFields(P p)
{
p(mBrightness);
p(mTexture);
}
Skybox::Skybox()
{
// This shouldn't normally happen, as filtered textures are generated when a radiance texture is assigned, but
// we check for it anyway (something could have gone wrong).
if(mTexture.isLoaded())
{
if (mFilteredRadiance == nullptr || mIrradiance == nullptr)
filterTexture();
}
}
Skybox::~Skybox()
{
if (mRendererTask != nullptr)
mRendererTask->cancel();
}
void Skybox::filterTexture()
{
// If previous rendering task exists, cancel it
if (mRendererTask != nullptr)
mRendererTask->cancel();
{
TEXTURE_DESC cubemapDesc;
cubemapDesc.type = TEX_TYPE_CUBE_MAP;
cubemapDesc.format = PF_RG11B10F;
cubemapDesc.width = ct::IBLUtility::REFLECTION_CUBEMAP_SIZE;
cubemapDesc.height = ct::IBLUtility::REFLECTION_CUBEMAP_SIZE;
cubemapDesc.numMips = PixelUtil::getMaxMipmaps(cubemapDesc.width, cubemapDesc.height, 1, cubemapDesc.format);
cubemapDesc.usage = TU_STATIC | TU_RENDERTARGET;
mFilteredRadiance = Texture::_createPtr(cubemapDesc);
}
{
TEXTURE_DESC irradianceCubemapDesc;
irradianceCubemapDesc.type = TEX_TYPE_CUBE_MAP;
irradianceCubemapDesc.format = PF_RG11B10F;
irradianceCubemapDesc.width = ct::IBLUtility::IRRADIANCE_CUBEMAP_SIZE;
irradianceCubemapDesc.height = ct::IBLUtility::IRRADIANCE_CUBEMAP_SIZE;
irradianceCubemapDesc.numMips = 0;
irradianceCubemapDesc.usage = TU_STATIC | TU_RENDERTARGET;
mIrradiance = Texture::_createPtr(irradianceCubemapDesc);
}
auto renderComplete = [this]()
{
mRendererTask = nullptr;
};
SPtr<ct::Skybox> coreSkybox = getCore();
SPtr<ct::Texture> coreFilteredRadiance = mFilteredRadiance->getCore();
SPtr<ct::Texture> coreIrradiance = mIrradiance->getCore();
auto filterSkybox = [coreFilteredRadiance, coreIrradiance, coreSkybox]()
{
// Filter radiance
ct::gIBLUtility().scaleCubemap(coreSkybox->getTexture(), 0, coreFilteredRadiance, 0);
ct::gIBLUtility().filterCubemapForSpecular(coreFilteredRadiance, nullptr);
coreSkybox->mFilteredRadiance = coreFilteredRadiance;
// Generate irradiance
ct::gIBLUtility().filterCubemapForIrradiance(coreSkybox->getTexture(), coreIrradiance);
coreSkybox->mIrradiance = coreIrradiance;
return true;
};
mRendererTask = ct::RendererTask::create("SkyboxFilter", filterSkybox);
mRendererTask->onComplete.connect(renderComplete);
ct::gRenderer()->addTask(mRendererTask);
}
void Skybox::setTexture(const HTexture& texture)
{
mTexture = texture;
mFilteredRadiance = nullptr;
mIrradiance = nullptr;
if(mTexture.isLoaded())
filterTexture();
_markCoreDirty((ActorDirtyFlag)SkyboxDirtyFlag::Texture);
}
SPtr<ct::Skybox> Skybox::getCore() const
{
return std::static_pointer_cast<ct::Skybox>(mCoreSpecific);
}
SPtr<Skybox> Skybox::createEmpty()
{
Skybox* skybox = new (bs_alloc<Skybox>()) Skybox();
SPtr<Skybox> skyboxPtr = bs_core_ptr<Skybox>(skybox);
skyboxPtr->_setThisPtr(skyboxPtr);
return skyboxPtr;
}
SPtr<Skybox> Skybox::create()
{
SPtr<Skybox> skyboxPtr = createEmpty();
skyboxPtr->initialize();
return skyboxPtr;
}
SPtr<ct::CoreObject> Skybox::createCore() const
{
SPtr<ct::Texture> radiance;
if (mTexture.isLoaded(false))
radiance = mTexture->getCore();
SPtr<ct::Texture> filteredRadiance;
if (mFilteredRadiance)
filteredRadiance = mFilteredRadiance->getCore();
SPtr<ct::Texture> irradiance;
if (mIrradiance)
irradiance = mIrradiance->getCore();
ct::Skybox* skybox = new (bs_alloc<ct::Skybox>()) ct::Skybox(radiance, filteredRadiance, irradiance);
SPtr<ct::Skybox> skyboxPtr = bs_shared_ptr<ct::Skybox>(skybox);
skyboxPtr->_setThisPtr(skyboxPtr);
return skyboxPtr;
}
CoreSyncData Skybox::syncToCore(FrameAlloc* allocator)
{
UINT32 size = 0;
size += rtti_size(getCoreDirtyFlags());
size += coreSyncGetElemSize((SceneActor&)*this);
size += coreSyncGetElemSize(*this);
UINT8* buffer = allocator->alloc(size);
Bitstream stream(buffer, size);
rtti_write(getCoreDirtyFlags(), stream);
coreSyncWriteElem((SceneActor&)*this, stream);
coreSyncWriteElem(*this, stream);
return CoreSyncData(buffer, size);
}
void Skybox::_markCoreDirty(ActorDirtyFlag flags)
{
markCoreDirty((UINT32)flags);
}
RTTITypeBase* Skybox::getRTTIStatic()
{
return SkyboxRTTI::instance();
}
RTTITypeBase* Skybox::getRTTI() const
{
return Skybox::getRTTIStatic();
}
namespace ct
{
Skybox::Skybox(const SPtr<Texture>& radiance, const SPtr<Texture>& filteredRadiance, const SPtr<Texture>& irradiance)
:mFilteredRadiance(filteredRadiance), mIrradiance(irradiance)
{
mTexture = radiance;
}
Skybox::~Skybox()
{
gRenderer()->notifySkyboxRemoved(this);
}
void Skybox::initialize()
{
gRenderer()->notifySkyboxAdded(this);
CoreObject::initialize();
}
void Skybox::syncToCore(const CoreSyncData& data)
{
Bitstream stream(data.getBuffer(), data.getBufferSize());
SkyboxDirtyFlag dirtyFlags;
bool oldIsActive = mActive;
rtti_read(dirtyFlags, stream);
coreSyncReadElem((SceneActor&)*this, stream);
coreSyncReadElem(*this, stream);
if (oldIsActive != mActive)
{
if (mActive)
gRenderer()->notifySkyboxAdded(this);
else
gRenderer()->notifySkyboxRemoved(this);
}
else
{
if (dirtyFlags != SkyboxDirtyFlag::Texture)
{
gRenderer()->notifySkyboxRemoved(this);
gRenderer()->notifySkyboxAdded(this);
}
}
}
}
}
| 25.864407
| 124
| 0.710518
|
hhyyrylainen
|
b1135147f3327846a203cb35f53ff558946f9eb5
| 2,718
|
hpp
|
C++
|
include/boost/webclient/asio/has_timeout.hpp
|
madmongo1/webclient
|
7eb52899443a76ced83b6f286b0e0d688f02fc65
|
[
"BSL-1.0"
] | 3
|
2020-06-12T02:22:41.000Z
|
2021-03-23T14:18:01.000Z
|
include/boost/webclient/asio/has_timeout.hpp
|
madmongo1/webclient
|
7eb52899443a76ced83b6f286b0e0d688f02fc65
|
[
"BSL-1.0"
] | 1
|
2020-06-12T02:29:08.000Z
|
2020-07-18T10:07:05.000Z
|
include/boost/webclient/asio/has_timeout.hpp
|
madmongo1/webclient
|
7eb52899443a76ced83b6f286b0e0d688f02fc65
|
[
"BSL-1.0"
] | null | null | null |
//
// Copyright (c) 2020 Richard Hodges (hodges.r@gmail.com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/madmongo1/webclient
//
// This project was made possible with the generous support of:
// The C++ Alliance (https://cppalliance.org/)
// Jetbrains (https://www.jetbrains.com/)
//
// Talk to us on Slack (https://cppalliance.org/slack/)
//
// Many thanks to Vinnie Falco for continuous mentoring and support
//
#ifndef BOOST_WEBCLIENT_ASIO__HAS_TIMEOUT_HPP
#define BOOST_WEBCLIENT_ASIO__HAS_TIMEOUT_HPP
#include <boost/asio/high_resolution_timer.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/beast/core/bind_handler.hpp>
#include <boost/webclient/asio/has_error_code.hpp>
#include <boost/webclient/config.hpp>
namespace boost { namespace webclient { namespace asio {
/// @brief an async op mixin to manage a timeout
template < class Derived >
struct has_timeout
{
protected:
template < class Executor >
has_timeout(Executor exec)
: timer_(std::move(exec))
{
}
struct timeout_event
{
};
template < class Self >
void initiate_timout(Self self, net::high_resolution_timer::duration how_long)
{
assert(!timer_outstanding_);
timer_outstanding_ = true;
timer_.expires_after(how_long);
timer_.async_wait(boost::beast::bind_front_handler(std::move(self), timeout_event()));
}
template < class Self >
void initiate_timout(Self self, net::high_resolution_timer::time_point when)
{
assert(!timer_outstanding_);
timer_outstanding_ = true;
timer_.expires_at(when);
timer_.async_wait(boost::beast::bind_front_handler(std::move(self), timeout_event()));
}
auto cancel_timeout() -> void { timer_.cancel(); }
template < class Self >
void operator()(Self &self, timeout_event, error_code ec)
{
auto &this_ = *static_cast< Derived * >(this);
assert(timer_outstanding_);
timer_outstanding_ = false;
if (!ec)
{
ec = net::error::timed_out;
this_.on_timeout();
}
auto &err_ = static_cast< has_error_code & >(this_);
this_(self, err_.set_error(ec));
}
auto timeout_outstanding() const -> bool { return timer_outstanding_; }
// customisation point
auto on_timeout() -> void {}
private:
net::high_resolution_timer timer_;
bool timer_outstanding_ = false;
};
}}} // namespace boost::webclient::asio
#endif // BOOST_WEBCLIENT_ASIO__HAS_TIMEOUT_HPP
| 28.610526
| 94
| 0.668874
|
madmongo1
|
b11426218e399d5f9c11b9fd2a26731b719f63d4
| 3,042
|
cc
|
C++
|
gr-dip/lib/gradient_magnitude_impl.cc
|
mattdarc/gr-dip
|
34d2a0d3ec8b78376928df48d4433ab813f702d1
|
[
"MIT"
] | 1
|
2018-05-16T04:24:06.000Z
|
2018-05-16T04:24:06.000Z
|
gr-dip/lib/gradient_magnitude_impl.cc
|
mattdarc/gnuradio-image-processing
|
34d2a0d3ec8b78376928df48d4433ab813f702d1
|
[
"MIT"
] | null | null | null |
gr-dip/lib/gradient_magnitude_impl.cc
|
mattdarc/gnuradio-image-processing
|
34d2a0d3ec8b78376928df48d4433ab813f702d1
|
[
"MIT"
] | null | null | null |
/* -*- c++ -*- */
/*
* Copyright 2018 <+YOU OR YOUR COMPANY+>.
*
* This is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gnuradio/io_signature.h>
#include "gradient_magnitude_impl.h"
namespace gr {
namespace dip {
gradient_magnitude::sptr
gradient_magnitude::make()
{
return gnuradio::get_initial_sptr
(new gradient_magnitude_impl());
}
/*
* The private constructor
*/
gradient_magnitude_impl::gradient_magnitude_impl()
: gr::sync_block("gradient_magnitude",
gr::io_signature::make(2, 2, sizeof(cv::Mat)),
gr::io_signature::make(1, 1, sizeof(cv::Mat))),
d_sent(false)
{}
/*
* Our virtual destructor.
*/
gradient_magnitude_impl::~gradient_magnitude_impl()
{
d_result.release();
d_dx.release();
d_dy.release();
}
int
gradient_magnitude_impl::work(int noutput_items,
gr_vector_const_void_star &input_items,
gr_vector_void_star &output_items)
{
const cv::Mat *inX = (const cv::Mat *) input_items[0];
const cv::Mat *inY = (const cv::Mat *) input_items[1];
cv::Mat *out = (cv::Mat *) output_items[0];
static int i = 0;
memcpy(&d_dx, inX, sizeof(d_dx));
memcpy(&d_dy, inY, sizeof(d_dy));
// Do <+signal processing+>
if((d_dx.empty() || d_dy.empty()) && !d_sent)
{
std::cout << __func__ << "Received empty image\n";
return 1;
}
else if(!d_sent)
{
// make sure that it is a grayscale image
if(d_dx.channels() != 1 || d_dy.channels() != 1)
{
// image is not grayscale
throw std::runtime_error ("Too many channels, not grayscale image");
}
// get the magnitude of the gradients
cv::magnitude(d_dx, d_dy, d_result);
// send to buffer
memcpy(out, &d_result, sizeof(d_result));
if (++i > 1) return -1;
d_sent = true;
// Tell runtime system how many input items we consumed on
// each input stream.
consume_each (noutput_items);
}
// Tell runtime system how many output items we produced.
return noutput_items;
}
} /* namespace dip */
} /* namespace gr */
| 29.25
| 82
| 0.605523
|
mattdarc
|
b116bf4434fee9f330b2513eec2eb44336c5973e
| 435
|
cpp
|
C++
|
Holiday Of Equality.cpp
|
manu-karenite/Codeforces-Solutions
|
c963a0186c6530ea8a785780fc4d68ed539e8c6e
|
[
"MIT"
] | 1
|
2021-04-07T05:13:21.000Z
|
2021-04-07T05:13:21.000Z
|
Holiday Of Equality.cpp
|
manu-karenite/Codeforces-Solutions
|
c963a0186c6530ea8a785780fc4d68ed539e8c6e
|
[
"MIT"
] | null | null | null |
Holiday Of Equality.cpp
|
manu-karenite/Codeforces-Solutions
|
c963a0186c6530ea8a785780fc4d68ed539e8c6e
|
[
"MIT"
] | null | null | null |
/*
This code is written by Manavesh Narendra
E-mail : manu.karenite@gmail.com
LinkedIn : https://www.linkedin.com/in/manavesh-narendra-489833196/
*/
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int arr[n];
for(int i=0;i<n;i++)
cin>>arr[i];
sort(arr,arr+n);
int maximum=arr[n-1];
int count=0;
for(int i=0;i<n-1;i++)
{
count+=maximum-arr[i];
}
cout<<count;
return 0;
}
| 15
| 67
| 0.611494
|
manu-karenite
|
b1238ce5a116d004e1fdf30c2a67e67bad42044b
| 20,591
|
cpp
|
C++
|
test/matcher.cpp
|
amritbrar/newsboat
|
fdef6fc5558aaf0baa3b8c185b335ca577535a33
|
[
"MIT"
] | null | null | null |
test/matcher.cpp
|
amritbrar/newsboat
|
fdef6fc5558aaf0baa3b8c185b335ca577535a33
|
[
"MIT"
] | 63
|
2020-10-05T07:01:49.000Z
|
2022-03-15T20:08:22.000Z
|
test/matcher.cpp
|
amritbrar/newsboat
|
fdef6fc5558aaf0baa3b8c185b335ca577535a33
|
[
"MIT"
] | null | null | null |
#include "matcher.h"
#include "3rd-party/catch.hpp"
#include <map>
#include "matchable.h"
#include "matcherexception.h"
#include "test-helpers/stringmaker/optional.h"
using namespace newsboat;
class MatcherMockMatchable : public Matchable {
public:
MatcherMockMatchable() = default;
MatcherMockMatchable(
std::initializer_list<std::pair<const std::string, std::string>>
data)
: m_data(data)
{}
nonstd::optional<std::string> attribute_value(const std::string& attribname)
const override
{
const auto it = m_data.find(attribname);
if (it != m_data.cend()) {
return it->second;
}
return nonstd::nullopt;
}
private:
std::map<std::string, std::string> m_data;
};
TEST_CASE("Operator `=` checks if field has given value", "[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"abcd", "xyz"}});
REQUIRE(m.parse("abcd = \"xyz\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("abcd = \"uiop\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Works with numbers") {
MatcherMockMatchable mock({{"answer", "42"}});
REQUIRE(m.parse("answer = 42"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("answer = 0042"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("answer = 13"));
REQUIRE_FALSE(m.matches(&mock));
SECTION("...but converts arguments to strings to compare") {
MatcherMockMatchable mock({{"agent", "007"}});
REQUIRE(m.parse("agent = 7"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("agent = 007"));
REQUIRE(m.matches(&mock));
}
}
SECTION("Doesn't work with ranges") {
MatcherMockMatchable mock({{"answer", "42"}});
REQUIRE(m.parse("answer = 0:100"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("answer = 100:200"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("answer = 42:200"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("answer = 0:42"));
REQUIRE_FALSE(m.matches(&mock));
}
}
TEST_CASE("Operator `!=` checks if field doesn't have given value", "[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"abcd", "xyz"}});
REQUIRE(m.parse("abcd != \"uiop\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("abcd != \"xyz\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Works with numbers") {
MatcherMockMatchable mock({{"answer", "42"}});
REQUIRE(m.parse("answer != 13"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("answer != 42"));
REQUIRE_FALSE(m.matches(&mock));
SECTION("...but converts arguments to strings to compare") {
MatcherMockMatchable mock({{"agent", "007"}});
REQUIRE(m.parse("agent != 7"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("agent != 007"));
REQUIRE_FALSE(m.matches(&mock));
}
}
SECTION("Doesn't work with ranges") {
MatcherMockMatchable mock({{"answer", "42"}});
REQUIRE(m.parse("answer != 0:100"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("answer != 100:200"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("answer != 42:200"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("answer != 0:42"));
REQUIRE(m.matches(&mock));
}
}
TEST_CASE("Operator `=~` checks if field matches given regex", "[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA =~ \".\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ \"123\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ \"234\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ \"45\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ \"^12345$\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ \"^123456$\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Converts numbers to strings and uses them as regexes") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA =~ 12345"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ 1"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ 45"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ 9"));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Treats ranges as strings") {
MatcherMockMatchable mock({{"AAAA", "12345"}, {"range", "0:123"}});
REQUIRE(m.parse("AAAA =~ 0:123456"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ 12345:99999"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA =~ 0:12345"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("range =~ 0:123"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("range =~ 0:12"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("range =~ 0:1234"));
REQUIRE_FALSE(m.matches(&mock));
}
}
TEST_CASE("Matcher throws if expression contains undefined fields", "[Matcher]")
{
MatcherMockMatchable mock;
Matcher m;
REQUIRE(m.parse("BBBB =~ \"foo\""));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
REQUIRE(m.parse("BBBB # \"foo\""));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
REQUIRE(m.parse("BBBB < 0"));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
REQUIRE(m.parse("BBBB > 0"));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
REQUIRE(m.parse("BBBB between 1:23"));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
}
TEST_CASE("Matcher throws if regex passed to `=~` or `!~` is invalid",
"[Matcher]")
{
MatcherMockMatchable mock({{"AAAA", "12345"}});
Matcher m;
REQUIRE(m.parse("AAAA =~ \"[[\""));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
REQUIRE(m.parse("AAAA !~ \"[[\""));
REQUIRE_THROWS_AS(m.matches(&mock), MatcherException);
}
TEST_CASE("Operator `!~` checks if field doesn't match given regex",
"[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA !~ \".\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"123\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"234\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"45\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"^12345$\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"567\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ \"number\""));
REQUIRE(m.matches(&mock));
}
SECTION("Converts numbers into strings and uses them as regexes") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA !~ 12345"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ 1"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ 45"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ 9"));
REQUIRE(m.matches(&mock));
}
SECTION("Doesn't work with ranges") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA !~ 0:123456"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ 12345:99999"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA !~ 0:12345"));
REQUIRE(m.matches(&mock));
}
}
TEST_CASE("Operator `#` checks if space-separated list contains given value",
"[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"tags", "foo bar baz quux"}});
REQUIRE(m.parse("tags # \"foo\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("tags # \"baz\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("tags # \"quux\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("tags # \"uu\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("tags # \"xyz\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("tags # \"foo bar\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("tags # \"foo\" and tags # \"bar\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("tags # \"foo\" and tags # \"xyz\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("tags # \"foo\" or tags # \"xyz\""));
REQUIRE(m.matches(&mock));
}
SECTION("Works with numbers") {
MatcherMockMatchable mock({{"fibonacci", "1 1 2 3 5 8 13 21 34"}});
REQUIRE(m.parse("fibonacci # 1"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci # 3"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci # 4"));
REQUIRE_FALSE(m.matches(&mock));
SECTION("...but convers them to strings to look them up") {
REQUIRE(m.parse("fibonacci # \"1\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci # \"3\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci # \"4\""));
REQUIRE_FALSE(m.matches(&mock));
}
}
SECTION("Doesn't work with ranges") {
MatcherMockMatchable mock({{"fibonacci", "1 1 2 3 5 8 13 21 34"}});
REQUIRE(m.parse("fibonacci # 1:5"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("fibonacci # 3:100"));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Works even on single-value lists") {
MatcherMockMatchable mock({{"values", "one"}, {"number", "1"}});
REQUIRE(m.parse("values # \"one\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("number # 1"));
REQUIRE(m.matches(&mock));
}
}
TEST_CASE("Operator `!#` checks if field doesn't contain given value",
"[Matcher]")
{
Matcher m;
SECTION("Works with strings") {
MatcherMockMatchable mock({{"tags", "foo bar baz quux"}});
REQUIRE(m.parse("tags !# \"nein\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("tags !# \"foo\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Works with numbers") {
MatcherMockMatchable mock({{"fibonacci", "1 1 2 3 5 8 13 21 34"}});
REQUIRE(m.parse("fibonacci !# 1"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("fibonacci !# 9"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci !# 4"));
REQUIRE(m.matches(&mock));
SECTION("...but convers them to strings to look them up") {
REQUIRE(m.parse("fibonacci !# \"1\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("fibonacci !# \"9\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci !# \"4\""));
REQUIRE(m.matches(&mock));
}
}
SECTION("Doesn't work with ranges") {
MatcherMockMatchable mock({{"fibonacci", "1 1 2 3 5 8 13 21 34"}});
REQUIRE(m.parse("fibonacci !# 1:5"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("fibonacci !# 7:35"));
REQUIRE(m.matches(&mock));
}
SECTION("Works even on single-value lists") {
MatcherMockMatchable mock({{"values", "one"}, {"number", "1"}});
REQUIRE(m.parse("values !# \"one\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("values !# \"two\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("number !# 1"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("number !# 2"));
REQUIRE(m.matches(&mock));
}
}
TEST_CASE(
"Operators `>`, `>=`, `<` and `<=` compare field's value to given "
"value",
"[Matcher]")
{
Matcher m;
SECTION("With string arguments, converts arguments to numbers") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
SECTION(">") {
REQUIRE(m.parse("AAAA > \"12344\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA > \"12345\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA > \"123456\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("<") {
REQUIRE(m.parse("AAAA < \"12345\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA < \"12346\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA < \"123456\""));
REQUIRE(m.matches(&mock));
}
SECTION(">=") {
REQUIRE(m.parse("AAAA >= \"12344\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA >= \"12345\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA >= \"12346\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("<=") {
REQUIRE(m.parse("AAAA <= \"12344\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA <= \"12345\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA <= \"12346\""));
REQUIRE(m.matches(&mock));
}
SECTION("Only numeric prefix is used for conversion") {
MatcherMockMatchable mock({{"AAAA", "12345xx"}});
REQUIRE(m.parse("AAAA >= \"12345\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA > \"1234a\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA < \"12345a\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA < \"1234a\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA < \"9999b\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("If conversion fails, zero is used") {
MatcherMockMatchable mock({{"zero", "0"}, {"same_zero", "yeah"}});
REQUIRE(m.parse("zero < \"unknown\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("zero > \"unknown\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("zero <= \"unknown\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("zero >= \"unknown\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("same_zero < \"0\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("same_zero > \"0\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("same_zero <= \"0\""));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("same_zero >= \"0\""));
REQUIRE(m.matches(&mock));
}
}
SECTION("Work with numbers") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA > 12344"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA > 12345"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA >= 12345"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA < 12345"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA <= 12345"));
REQUIRE(m.matches(&mock));
}
SECTION("Don't work with ranges") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA > 0:99999"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA < 0:99999"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA >= 0:99999"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA <= 0:99999"));
REQUIRE_FALSE(m.matches(&mock));
}
}
TEST_CASE("Operator `between` checks if field's value is in given range",
"[Matcher]")
{
Matcher m;
SECTION("Doesn't work with strings") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA between \"123\""));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA between \"12399\""));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Doesn't work with numbers") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA between 1"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA between 12345"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA between 99999"));
REQUIRE_FALSE(m.matches(&mock));
}
SECTION("Works with ranges") {
MatcherMockMatchable mock({{"AAAA", "12345"}});
REQUIRE(m.parse("AAAA between 0:12345"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA between 12345:12345"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("AAAA between 23:12344"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("AAAA between 12346:12344"));
REQUIRE(m.matches(&mock));
SECTION("...converting numeric prefix of the attribute if necessary") {
MatcherMockMatchable mock({{"value", "123four"}, {"practically_zero", "sure"}});
REQUIRE(m.parse("value between 122:124"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("value between 124:130"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse("practically_zero between 0:1"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("practically_zero between 1:100"));
REQUIRE_FALSE(m.matches(&mock));
}
}
}
TEST_CASE("get_expression() returns previously parsed expression", "[Matcher]")
{
Matcher m("AAAA between 1:30000");
REQUIRE(m.get_expression() == "AAAA between 1:30000");
SECTION("after parse(), get_expression() returns the latest parsed expression") {
REQUIRE(m.parse("AAAA == 42"));
REQUIRE(m.get_expression() == "AAAA == 42");
}
}
TEST_CASE("Regexes are matched case-insensitively", "[Matcher]")
{
// Inspired by https://github.com/newsboat/newsboat/issues/642
const auto require_matches = [](std::string regex) {
MatcherMockMatchable mock({{"abcd", "xyz"}});
Matcher m;
REQUIRE(m.parse("abcd =~ \"" + regex + "\""));
REQUIRE(m.matches(&mock));
};
require_matches("xyz");
require_matches("xYz");
require_matches("xYZ");
require_matches("Xyz");
require_matches("yZ");
require_matches("^xYZ");
require_matches("xYz$");
require_matches("^Xyz$");
require_matches("^xY");
require_matches("yZ$");
}
TEST_CASE("=~ and !~ use POSIX extended regex syntax", "[Matcher]")
{
// This syntax is documented in The Open Group Base Specifications Issue 7,
// IEEE Std 1003.1-2008 Section 9, "Regular Expressions":
// https://pubs.opengroup.org/onlinepubs/9699919799.2008edition/basedefs/V1_chap09.html
// Since POSIX extended regular expressions are pretty basic, it's hard to
// find stuff that they support but other engines don't. So in order to
// ensure that we're using EREs, these tests try stuff that's *not*
// supported by EREs.
//
// Ideas gleaned from https://www.regular-expressions.info/refcharacters.html
Matcher m;
// Supported by Perl, PCRE, PHP and others
SECTION("No support for escape sequence") {
MatcherMockMatchable mock({{"attr", "*]+"}});
REQUIRE(m.parse(R"#(attr =~ "\Q*]+\E")#"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse(R"#(attr !~ "\Q*]+\E")#"));
REQUIRE(m.matches(&mock));
}
SECTION("No support for hexadecimal escape") {
MatcherMockMatchable mock({{"attr", "value"}});
REQUIRE(m.parse(R"#(attr =~ "^va\x6Cue")#"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse(R"#(attr !~ "^va\x6Cue")#"));
REQUIRE(m.matches(&mock));
}
SECTION("No support for \\a as alert/bell control character") {
MatcherMockMatchable mock({{"attr", "\x07"}});
REQUIRE(m.parse(R"#(attr =~ "\a")#"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse(R"#(attr !~ "\a")#"));
REQUIRE(m.matches(&mock));
}
SECTION("No support for \\b as backspace control character") {
MatcherMockMatchable mock({{"attr", "\x08"}});
REQUIRE(m.parse(R"#(attr =~ "\b")#"));
REQUIRE_FALSE(m.matches(&mock));
REQUIRE(m.parse(R"#(attr !~ "\b")#"));
REQUIRE(m.matches(&mock));
}
// If you add more checks to this test, consider adding the same to RegexManager tests
}
TEST_CASE("get_parse_error() returns textual description of last "
"filter-expression parsing error",
"[Matcher]")
{
Matcher m;
REQUIRE_FALSE(m.parse("=!"));
REQUIRE(m.get_parse_error() != "");
}
TEST_CASE("Space characters in filter expression don't affect parsing",
"[Matcher]")
{
const auto check = [](std::string expression) {
INFO("input expression: " << expression);
MatcherMockMatchable mock({{"array", "foo bar baz"}});
Matcher m;
REQUIRE(m.parse(expression));
REQUIRE(m.matches(&mock));
};
check("array # \"bar\"");
check(" array # \"bar\"");
check("array # \"bar\"");
check("array # \"bar\"");
check("array # \"bar\" ");
check("array# \"bar\" ");
check(" array # \"bar\" ");
}
TEST_CASE("Only space characters are considered whitespace by filter parser",
"[Matcher]")
{
const auto check = [](std::string expression) {
INFO("input expression: " << expression);
MatcherMockMatchable mock({{"attr", "value"}});
Matcher m;
REQUIRE_FALSE(m.parse(expression));
};
check("attr\t= \"value\"");
check("attr =\t\"value\"");
check("attr\n=\t\"value\"");
check("attr\v=\"value\"");
check("attr=\"value\"\r\n");
}
TEST_CASE("Whitespace before and/or is not required", "[Matcher]")
{
MatcherMockMatchable mock({{"x", "42"}, {"y", "0"}});
Matcher m;
REQUIRE(m.parse("x = 42and y=0"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("x = \"42\"and y=0"));
REQUIRE(m.matches(&mock));
REQUIRE(m.parse("x = \"42\"or y=42"));
REQUIRE(m.matches(&mock));
}
TEST_CASE("string_to_num() converts numeric prefix of the string to int",
"[Matcher]")
{
REQUIRE(Matcher::string_to_num("7654") == 7654);
REQUIRE(Matcher::string_to_num("123foo") == 123);
REQUIRE(Matcher::string_to_num("-999999bar") == -999999);
REQUIRE(Matcher::string_to_num("-2147483648min") == -2147483648);
REQUIRE(Matcher::string_to_num("2147483647 is ok") == 2147483647);
// On under-/over-flow, returns min/max representable value
REQUIRE(Matcher::string_to_num("-2147483649 is too small for i32") ==
-2147483648);
REQUIRE(Matcher::string_to_num("2147483648 is too large for i32") ==
2147483647);
}
TEST_CASE("string_to_num() returns 0 if there is no numeric prefix",
"[Matcher]")
{
REQUIRE(Matcher::string_to_num("hello") == 0);
REQUIRE(Matcher::string_to_num("") == 0);
}
| 24.77858
| 88
| 0.635957
|
amritbrar
|
b127b77c2f1c5fa80304bae37934bf96e265a1d1
| 314
|
hpp
|
C++
|
Source/Colyseus/Protocol.hpp
|
endel/colyseus-cocos2d-x
|
96a12a15d1f70f061365769e6cc84ba9bde49c72
|
[
"MIT"
] | 15
|
2019-01-24T22:05:12.000Z
|
2022-01-19T08:40:42.000Z
|
Source/Colyseus/Protocol.hpp
|
endel/colyseus-cocos2d-x
|
96a12a15d1f70f061365769e6cc84ba9bde49c72
|
[
"MIT"
] | 3
|
2019-02-09T14:19:21.000Z
|
2021-05-08T01:41:38.000Z
|
Source/Colyseus/Protocol.hpp
|
endel/colyseus-cocos2d-x
|
96a12a15d1f70f061365769e6cc84ba9bde49c72
|
[
"MIT"
] | 2
|
2019-02-05T04:52:12.000Z
|
2020-03-17T17:21:16.000Z
|
#ifndef Protocol_hpp
#define Protocol_hpp
enum class Protocol : int {
// Room-related (10~19)
JOIN_ROOM = 10,
JOIN_ERROR = 11,
LEAVE_ROOM = 12,
ROOM_DATA = 13,
ROOM_STATE = 14,
ROOM_STATE_PATCH = 15,
// Generic messages (50~60)
BAD_REQUEST = 50,
};
#endif /* Protocol_hpp */
| 17.444444
| 31
| 0.624204
|
endel
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.