hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move C++ code out of C headers

Browse Source 
The additions into the server.h header used C++ language which caused C
programs to fail to compile. Moved the implementation of the EMAverage
class into the private Server class in the server.hh header and exposed it
via functions in the server.h header. Also temporarily moved
almost_equal_server_scores into the public server.hh as there is no
service.hh header.
This commit is contained in:
Markus Mäkelä
2018-09-08 17:32:59 +03:00
parent 4f6990f90d
commit c81173e320
10 changed files with 85 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
server/modules/routing/readconnroute/readconnroute.cc
View File

@ -79,7 +79,7 @@
#include <string>
#include <vector>
#include <maxscale/alloc.h>
#include <maxscale/server.h>
#include <maxscale/server.hh>
#include <maxscale/router.h>
#include <maxbase/atomic.h>
#include <maxscale/spinlock.h>
@ -378,9 +378,9 @@ static MXS_ROUTER_SESSION* newSession(MXS_ROUTER* instance, MXS_SESSION* session
/* ref has a better score. */
candidate = ref;
}
else if (almost_equal_server_scores(ref->inv_weight * ref->connections,
candidate->inv_weight * candidate->connections)
&& ref->server->stats.n_connections < candidate->server->stats.n_connections)
else if (mxs::almost_equal_server_scores(ref->inv_weight * ref->connections,
candidate->inv_weight * candidate->connections) &&
ref->server->stats.n_connections < candidate->server->stats.n_connections)
{
/* The servers are about equally good, but ref has had fewer connections over time.
* TODO: On second thought, if the servers are currently about equally good,

8
server/modules/routing/readwritesplit/readwritesplit.hh
View File

@ -134,7 +134,7 @@ static const char gtid_wait_stmt[]
*/
using SRWBackendVector = std::vector<mxs::SRWBackend*>;
using BackendSelectFunction = std::function
<SRWBackendVector::const_iterator (const SRWBackendVector& sBackends)>;
<SRWBackendVector::iterator (SRWBackendVector& sBackends)>;
BackendSelectFunction get_backend_select_function(select_criteria_t);
struct Config
@ -385,9 +385,9 @@ std::pair<int, int> get_slave_counts(mxs::SRWBackendList& backends, mxs::SRWBack
*
* @return Valid iterator into argument backends, or end(backends) if empty
*/
SRWBackendVector::const_iterator find_best_backend(const SRWBackendVector& backends,
BackendSelectFunction select,
bool masters_accepts_reads);
SRWBackendVector::iterator find_best_backend(SRWBackendVector& backends,
BackendSelectFunction select,
bool masters_accepts_reads);
/*
* The following are implemented in rwsplit_tmp_table_multi.c

27
server/modules/routing/readwritesplit/rwsplit_select_backends.cc
View File

@ -57,8 +57,8 @@ static bool valid_for_slave(const SRWBackend& backend, const SRWBackend& master)
&& (!master || backend != master);
}
SRWBackendVector::const_iterator best_score(const SRWBackendVector& sBackends,
std::function<double(SERVER_REF* server)> server_score)
SRWBackendVector::iterator best_score(SRWBackendVector& sBackends,
std::function<double(SERVER_REF* server)> server_score)
{
double min {std::numeric_limits<double>::max()};
auto best = sBackends.end();
@ -76,7 +76,7 @@ SRWBackendVector::const_iterator best_score(const SRWBackendVector& sBackends,
}
/** Compare number of connections from this router in backend servers */
SRWBackendVector::const_iterator backend_cmp_router_conn(const SRWBackendVector& sBackends)
SRWBackendVector::iterator backend_cmp_router_conn(SRWBackendVector& sBackends)
{
static auto server_score = [](SERVER_REF* server) {
return server->inv_weight * server->connections;
@ -86,7 +86,7 @@ SRWBackendVector::const_iterator backend_cmp_router_conn(const SRWBackendVector&
}
/** Compare number of global connections in backend servers */
SRWBackendVector::const_iterator backend_cmp_global_conn(const SRWBackendVector& sBackends)
SRWBackendVector::iterator backend_cmp_global_conn(SRWBackendVector& sBackends)
{
static auto server_score = [](SERVER_REF* server) {
return server->inv_weight * server->server->stats.n_current;
@ -96,7 +96,7 @@ SRWBackendVector::const_iterator backend_cmp_global_conn(const SRWBackendVector&
}
/** Compare replication lag between backend servers */
SRWBackendVector::const_iterator backend_cmp_behind_master(const SRWBackendVector& sBackends)
SRWBackendVector::iterator backend_cmp_behind_master(SRWBackendVector& sBackends)
{
static auto server_score = [](SERVER_REF* server) {
return server->inv_weight * server->server->rlag;
@ -106,7 +106,7 @@ SRWBackendVector::const_iterator backend_cmp_behind_master(const SRWBackendVecto
}
/** Compare number of current operations in backend servers */
SRWBackendVector::const_iterator backend_cmp_current_load(const SRWBackendVector& sBackends)
SRWBackendVector::iterator backend_cmp_current_load(SRWBackendVector& sBackends)
{
static auto server_score = [](SERVER_REF* server) {
return server->inv_weight * server->server->stats.n_current_ops;
@ -115,7 +115,7 @@ SRWBackendVector::const_iterator backend_cmp_current_load(const SRWBackendVector
return best_score(sBackends, server_score);
}
SRWBackendVector::const_iterator backend_cmp_response_time(const SRWBackendVector& sBackends)
SRWBackendVector::iterator backend_cmp_response_time(SRWBackendVector& sBackends)
{
const int SZ = sBackends.size();
double slot[SZ];
@ -125,8 +125,9 @@ SRWBackendVector::const_iterator backend_cmp_response_time(const SRWBackendVecto
for (int i = 0; i < SZ; ++i)
{
SERVER_REF* server = (**sBackends[i]).backend();
auto ave = server->server->response_time->average();
if (ave == 0)
auto ave = server_response_time_average(server->server);
if (ave==0)
{
constexpr double very_quick = 1.0 / 10000000; // arbitrary very short duration (0.1
// microseconds)
@ -197,9 +198,9 @@ BackendSelectFunction get_backend_select_function(select_criteria_t sc)
*
* @return iterator to the best slave or backends.end() if none found
*/
SRWBackendVector::const_iterator find_best_backend(const SRWBackendVector& backends,
BackendSelectFunction select,
bool masters_accepts_reads)
SRWBackendVector::iterator find_best_backend(SRWBackendVector& backends,
BackendSelectFunction select,
bool masters_accepts_reads)
{
// Group backends by priority. The set of highest priority backends will then compete.
std::map<int, SRWBackendVector> priority_map;
@ -288,7 +289,7 @@ static void log_server_connections(select_criteria_t criteria, const SRWBackendL
case LOWEST_RESPONSE_TIME:
{
maxbase::Duration response_ave(b->server->response_time->average());
maxbase::Duration response_ave(server_response_time_average(b->server));
std::ostringstream os;
os << response_ave;
MXS_INFO("Average response time : %s from \t[%s]:%d %s",

2
server/modules/routing/readwritesplit/rwsplitsession.cc
View File

@ -648,7 +648,7 @@ void RWSplitSession::clientReply(GWBUF* writebuf, DCB* backend_dcb)
ResponseStat& stat = backend->response_stat();
stat.query_ended();
if (stat.is_valid() && (stat.sync_time_reached()
|| backend->server()->response_time->num_samples() == 0))
|| server_response_time_num_samples(backend->server()) == 0))
{
server_add_response_average(backend->server(),
stat.average().secs(),