ats-testing.h

Go to the documentation of this file.

/*
 This file is part of GNUnet.
 Copyright (C) 2010-2013 GNUnet e.V.

 GNUnet is free software: you can redistribute it and/or modify it
 under the terms of the GNU Affero General Public License as published
 by the Free Software Foundation, either version 3 of the License,
 or (at your option) any later version.

 GNUnet 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
 Affero General Public License for more details.

 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_core_service.h"
#include "gnunet_transport_service.h"

#define TEST_ATS_PREFERENCE_DEFAULT 1.0

#define TEST_MESSAGE_TYPE_PING 12345

#define TEST_MESSAGE_TYPE_PONG 12346

#define TEST_MESSAGE_SIZE 100


struct TestMessage
{
  struct GNUNET_MessageHeader header;

  uint8_t padding[TEST_MESSAGE_SIZE - sizeof (struct GNUNET_MessageHeader)];
};


struct BenchmarkPartner;

struct BenchmarkPeer;

struct GNUNET_ATS_TEST_Topology;

struct TrafficGenerator;

struct LoggingHandle;

enum GeneratorType
{
  GNUNET_ATS_TEST_TG_LINEAR,
  GNUNET_ATS_TEST_TG_CONSTANT,
  GNUNET_ATS_TEST_TG_RANDOM,
  GNUNET_ATS_TEST_TG_SINUS
};


typedef void (*GNUNET_ATS_TEST_TopologySetupDoneCallback) (
  void *cls,
  struct BenchmarkPeer *masters,
  struct BenchmarkPeer *slaves);

typedef void (*GNUNET_ATS_TEST_LogRequest) (
  void *cls,
  const struct GNUNET_HELLO_Address *address,
  int address_active,
  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
  const struct GNUNET_ATS_Properties *prop);

struct BenchmarkPeer
{
  struct GNUNET_TESTBED_Peer *peer;

  int no;

  int master;

  struct GNUNET_PeerIdentity id;

  struct GNUNET_TESTBED_Operation *peer_id_op;

  struct GNUNET_TESTBED_Operation *ats_perf_op;

  struct GNUNET_TESTBED_Operation *comm_op;

  struct GNUNET_ATS_PerformanceHandle *ats_perf_handle;

  struct TestbedConnectOperation *core_connect_ops;

  struct GNUNET_CORE_Handle *ch;

  struct GNUNET_TRANSPORT_CoreHandle *th;

  struct BenchmarkPeer *pref_partner;

  struct GNUNET_SCHEDULER_Task *ats_task;

  double pref_value;

  struct BenchmarkPartner *partners;

  int num_partners;

  int core_connections;

  int core_slave_connections;

  unsigned int total_messages_sent;

  unsigned int total_bytes_sent;

  unsigned int total_messages_received;

  unsigned int total_bytes_received;
};

struct TrafficGenerator
{
  struct TrafficGenerator *prev;
  struct TrafficGenerator *next;

  enum GeneratorType type;

  struct BenchmarkPeer *src;
  struct BenchmarkPartner *dest;

  long int base_rate;
  long int max_rate;
  struct GNUNET_TIME_Relative duration_period;

  struct GNUNET_SCHEDULER_Task *send_task;
  struct GNUNET_TIME_Absolute next_ping_transmission;
  struct GNUNET_TIME_Absolute time_start;
};


struct PreferenceGenerator
{
  struct PreferenceGenerator *prev;
  struct PreferenceGenerator *next;

  enum GeneratorType type;

  struct BenchmarkPeer *src;
  struct BenchmarkPartner *dest;

  enum GNUNET_ATS_PreferenceKind kind;

  long int base_value;
  long int max_value;
  struct GNUNET_TIME_Relative duration_period;
  struct GNUNET_TIME_Relative frequency;

  struct GNUNET_SCHEDULER_Task *set_task;
  struct GNUNET_TIME_Absolute next_ping_transmission;
  struct GNUNET_TIME_Absolute time_start;
};

struct BenchmarkPartner
{
  struct BenchmarkPeer *me;

  struct BenchmarkPeer *dest;

  struct GNUNET_MQ_Handle *mq;

  struct TrafficGenerator *tg;

  struct PreferenceGenerator *pg;

  struct GNUNET_TIME_Absolute last_message_sent;

  unsigned int total_app_rtt;

  unsigned int messages_sent;

  unsigned int bytes_sent;

  unsigned int messages_received;

  unsigned int bytes_received;

  struct GNUNET_ATS_Properties props;

  uint32_t bandwidth_in;

  uint32_t bandwidth_out;

  double pref_bandwidth;

  double pref_delay;
};


struct BenchmarkState
{
  int connected_ATS_service;

  int connected_COMM_service;

  int connected_PEERS;

  int connected_CORE;

  int benchmarking;
};


struct GNUNET_ATS_TEST_Topology
{
  struct GNUNET_SCHEDULER_Task *progress_task;

  int result;

  int test_core;

  char *solver;

  char *testname;

  char *pref_str;

  int pref_val;

  unsigned int num_masters;

  struct BenchmarkPeer *mps;

  unsigned int num_slaves;

  struct BenchmarkPeer *sps;

  struct GNUNET_TIME_Relative perf_duration;

  struct GNUNET_TIME_Relative log_frequency;

  struct BenchmarkState state;

  GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb;

  GNUNET_ATS_AddressInformationCallback ats_perf_cb;

  void *done_cb_cls;
};

enum OperationType
{
  START_SEND,
  STOP_SEND,
  START_PREFERENCE,
  STOP_PREFERENCE
};

struct Episode;

struct Experiment;

typedef void (*GNUNET_ATS_TESTING_EpisodeDoneCallback) (struct Episode *e);

typedef void (*GNUNET_ATS_TESTING_ExperimentDoneCallback) (
  struct Experiment *e,
  struct GNUNET_TIME_Relative duration,
  int success);

struct GNUNET_ATS_TEST_Operation
{
  struct GNUNET_ATS_TEST_Operation *next;
  struct GNUNET_ATS_TEST_Operation *prev;

  long long unsigned int src_id;
  long long unsigned int dest_id;

  long long unsigned int base_rate;
  long long unsigned int max_rate;
  struct GNUNET_TIME_Relative period;
  struct GNUNET_TIME_Relative frequency;

  enum OperationType type;
  enum GeneratorType gen_type;
  enum GNUNET_ATS_PreferenceKind pref_type;
};

struct Episode
{
  int id;
  struct Episode *next;
  struct GNUNET_TIME_Relative duration;

  struct GNUNET_ATS_TEST_Operation *head;
  struct GNUNET_ATS_TEST_Operation *tail;
};


struct Experiment
{
  char *name;
  char *cfg_file;
  unsigned long long int num_masters;
  unsigned long long int num_slaves;
  struct GNUNET_TIME_Relative log_freq;
  struct GNUNET_TIME_Relative max_duration;
  struct GNUNET_TIME_Relative total_duration;
  struct GNUNET_TIME_Absolute start_time;
  unsigned int num_episodes;
  struct Episode *start;

  struct GNUNET_SCHEDULER_Task *experiment_timeout_task;
  struct GNUNET_SCHEDULER_Task *episode_timeout_task;
  struct Episode *cur;

  GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb;
  GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb;
};


extern struct GNUNET_CONFIGURATION_Handle *cfg;

void
GNUNET_ATS_TEST_experimentation_run (
  struct Experiment *e,
  GNUNET_ATS_TESTING_EpisodeDoneCallback ep_done_cb,
  GNUNET_ATS_TESTING_ExperimentDoneCallback e_done_cb);


struct Experiment *
GNUNET_ATS_TEST_experimentation_load (const char *filename);


void
GNUNET_ATS_TEST_experimentation_stop (struct Experiment *e);


void
GNUNET_ATS_TEST_traffic_handle_ping (struct BenchmarkPartner *p);


void
GNUNET_ATS_TEST_traffic_handle_pong (struct BenchmarkPartner *p);


struct TrafficGenerator *
GNUNET_ATS_TEST_generate_traffic_start (struct BenchmarkPeer *src,
                                        struct BenchmarkPartner *dest,
                                        enum GeneratorType type,
                                        unsigned int base_rate,
                                        unsigned int max_rate,
                                        struct GNUNET_TIME_Relative period,
                                        struct GNUNET_TIME_Relative duration);


void
GNUNET_ATS_TEST_generate_traffic_stop (struct TrafficGenerator *tg);


void
GNUNET_ATS_TEST_generate_traffic_stop_all (void);


struct PreferenceGenerator *
GNUNET_ATS_TEST_generate_preferences_start (
  struct BenchmarkPeer *src,
  struct BenchmarkPartner *dest,
  enum GeneratorType type,
  unsigned int base_value,
  unsigned int value_rate,
  struct GNUNET_TIME_Relative period,
  struct GNUNET_TIME_Relative frequency,
  enum GNUNET_ATS_PreferenceKind kind);


void
GNUNET_ATS_TEST_generate_preferences_stop (struct PreferenceGenerator *pg);


void
GNUNET_ATS_TEST_generate_preferences_stop_all (void);


struct LoggingHandle *
GNUNET_ATS_TEST_logging_start (struct GNUNET_TIME_Relative log_frequency,
                               const char *testname,
                               struct BenchmarkPeer *masters,
                               int num_masters,
                               int num_slaves,
                               int verbose);


void
GNUNET_ATS_TEST_logging_clean_up (struct LoggingHandle *l);


void
GNUNET_ATS_TEST_logging_stop (struct LoggingHandle *l);


void
GNUNET_ATS_TEST_logging_now (struct LoggingHandle *l);


void
GNUNET_ATS_TEST_logging_write_to_file (struct LoggingHandle *l,
                                       const char *test_name,
                                       int plots);


struct BenchmarkPeer *
GNUNET_ATS_TEST_get_peer (int src);


struct BenchmarkPartner *
GNUNET_ATS_TEST_get_partner (int src, int dest);


void
GNUNET_ATS_TEST_create_topology (
  char *name,
  char *cfg_file,
  unsigned int num_slaves,
  unsigned int num_masters,
  int test_core,
  GNUNET_ATS_TEST_TopologySetupDoneCallback done_cb,
  void *done_cb_cls,
  GNUNET_ATS_TEST_LogRequest ats_perf_cb);


void
GNUNET_ATS_TEST_shutdown_topology (void);


/* end of file ats-testing.h */