@@ -26,5 +26,12 @@
 /cmake-*
 /debug
 .vscode/
-
+/scripts/benne/jpg/
+/scripts/benne/pdf/
 *.log
+
+datasets/
+
+*.egg-info/
+*.out
+results.txt
@@ -3,6 +3,10 @@
 cmake_minimum_required(VERSION 3.14)
 project(SESAME CXX)
 
+if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "")
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "" FORCE)
+endif()
+
 # Custom CMake find instructions and macros
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake;${CMAKE_MODULE_PATH}")
 include(cmake/macros.cmake)
@@ -19,7 +23,7 @@ message(STATUS "sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc
 message(STATUS "sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 11")
 
 # Set Optimization Flags
-set(CMAKE_CXX_FLAGS "-g -std=c++20 -Wall -Werror=return-type -fconcepts-diagnostics-depth=2 -lpthread -fopenmp -static -march=native")
+set(CMAKE_CXX_FLAGS "-g -std=c++20 -Wall -Werror=return-type -fconcepts-diagnostics-depth=2 -lpthread -fopenmp -march=native")
 set(CMAKE_CXX_FLAGS_DEBUG "-O0 -DNO_RACE_CHECK -DSESAME_DEBUG_MODE=1 -DDEBUG")
 set(CMAKE_CXX_FLAGS_RELEASE "-Wno-ignored-qualifiers -Wno-sign-compare -O3 -DNDEBUG")
 
@@ -58,6 +62,7 @@ if (ENABLE_UNIT_TESTS)
 endif ()
 
 find_package(OpenMP)
+find_package(gflags REQUIRED)
 
 # Print all used include directories
 message(STATUS "INCLUDE_DIRS:")
 
@@ -20,7 +20,7 @@ if (BUILD_BENCHMARKS)
     target_link_libraries(benchmark sesame gflags)
     if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/datasets)
         add_custom_target(bench_datasets ALL
-                    COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_SOURCE_DIR}/datasets ${CMAKE_CURRENT_BINARY_DIR}/datasets)
+                    COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_SOURCE_DIR}/../datasets ${CMAKE_CURRENT_BINARY_DIR}/datasets)
         add_dependencies(benchmark bench_datasets)
     endif (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/datasets)
     message("---Done building benchmarks")
 
@@ -17,8 +17,8 @@
 
 #include <filesystem>
 
-using namespace std::filesystem;
 using namespace std;
+using namespace std::filesystem;
 using namespace SESAME;
 
 DEFINE_int32(algo, 0, "Algorithm to use");
@@ -58,20 +58,27 @@ DEFINE_int32(time_window, 50, "Time window");
 DEFINE_int32(num_online_clusters, 80, "Number of online clusters");
 // SL-KMeans
 DEFINE_double(delta_grid, 0.2, "The delta parameter used int the grid for guessing the optimum.");
-DEFINE_int32(num_samples, 100, "Number of samples");
+DEFINE_int32(num_samples, 10, "Number of samples");
 // Generic
-DEFINE_int32(landmark, 1000, "Landmark");
-DEFINE_int32(sliding, 1000, "Sliding");
+DEFINE_int32(landmark, 10000, "Landmark");
+DEFINE_int32(sliding, 500, "Sliding");
 DEFINE_double(outlier_distance_threshold, 1000, "Outlier distance threshold");
 DEFINE_int32(outlier_cap, 100, "Outlier cap");
 DEFINE_double(outlier_density_threshold, 100, "Outlier density threshold");
 DEFINE_double(neighbor_distance, 200, "Neighbor distance");
-DEFINE_int32(k, 0, "KMeans K");
+DEFINE_int32(k, 7, "KMeans K");
 DEFINE_int32(arr_rate, 0, "Arrival rate");
 DEFINE_bool(run_offline, true, "Whether run offline clustering");
 DEFINE_bool(run_eval, true, "Whether run evaluation");
-DEFINE_bool(run_cmm, true, "Whether run CMM evaluation");
+DEFINE_bool(run_cmm, false, "Whether run CMM evaluation");
 DEFINE_bool(run_pur, true, "Whether run Purity evaluation");
+// Benne
+DEFINE_int32(obj, 0, "Objective: 0(balance), 1(accuracy), 2(efficiency)");
+DEFINE_int32(queue_size_threshold, 10000, "Benne queue size threshold");
+DEFINE_int32(dim_threshold, 30, "Benne dimension threshold");
+DEFINE_double(variance_threshold, 100.0, "Benne variance threshold");
+DEFINE_int32(outliers_num_threshold, 200, "Benne outliers threshold");
+DEFINE_double(outliers_dist_threshold, 50.0, "Benne outliers distance threshold");
 
 int main(int argc, char **argv)
 {
@@ -83,81 +90,63 @@ int main(int argc, char **argv)
               << "#                                                          #\n"
               << "############################################################"
                  "\033[0m\n";
-    sleep(2);
+    sleep(1);
 #endif
     // Parse parameters.
-    param_t param;
     gflags::ParseCommandLineFlags(&argc, &argv, true);
+    param_t param;
     param.algo = (AlgoType)FLAGS_algo;
-    BenchmarkUtils::defaultParam(param);
-    // gen from gen_flags.js
-    param.algo                       = (AlgoType)FLAGS_algo;
-    param.input_file                 = FLAGS_input_file;
-    param.num_points                 = FLAGS_num_points;
-    param.dim                        = FLAGS_dim;
-    param.num_clusters               = FLAGS_num_clusters;
-    param.max_in_nodes               = FLAGS_max_in_nodes;
-    param.max_leaf_nodes             = FLAGS_max_leaf_nodes;
-    param.distance_threshold         = FLAGS_distance_threshold;
-    param.seed                       = FLAGS_seed;
-    param.coreset_size               = FLAGS_coreset_size;
-    param.radius                     = FLAGS_radius;
-    param.delta                      = FLAGS_delta;
-    param.beta                       = FLAGS_beta;
-    param.buf_size                   = FLAGS_buf_size;
-    param.alpha                      = FLAGS_alpha;
-    param.lambda                     = FLAGS_lambda;
-    param.clean_interval             = FLAGS_clean_interval;
-    param.min_weight                 = FLAGS_min_weight;
-    param.base                       = FLAGS_base;
-    param.cm                         = FLAGS_cm;
-    param.cl                         = FLAGS_cl;
-    param.grid_width                 = FLAGS_grid_width;
-    param.min_points                 = FLAGS_min_points;
-    param.epsilon                    = FLAGS_epsilon;
-    param.mu                         = FLAGS_mu;
-    param.num_last_arr               = FLAGS_num_last_arr;
-    param.time_window                = FLAGS_time_window;
-    param.num_online_clusters        = FLAGS_num_online_clusters;
-    param.delta_grid                 = FLAGS_delta_grid;
-    param.num_samples                = FLAGS_num_samples;
-    param.landmark                   = FLAGS_landmark;
-    param.sliding                    = FLAGS_sliding;
-    param.outlier_distance_threshold = FLAGS_outlier_distance_threshold;
-    param.outlier_cap                = FLAGS_outlier_cap;
-    param.outlier_density_threshold  = FLAGS_outlier_density_threshold;
-    param.neighbor_distance          = FLAGS_neighbor_distance;
-    param.k                          = FLAGS_k;
-    param.arr_rate                   = FLAGS_arr_rate;
-    param.run_offline                = FLAGS_run_offline;
-    param.run_eval                   = FLAGS_run_eval;
-    param.run_cmm                    = FLAGS_run_cmm;
-    param.run_pur                    = FLAGS_run_pur;
+    param.algo                          = (AlgoType)FLAGS_algo;
+    param.input_file                    = FLAGS_input_file;
+    param.num_points                    = FLAGS_num_points;
+    param.dim                           = FLAGS_dim;
+    param.num_clusters                  = FLAGS_num_clusters;
+    param.max_in_nodes                  = FLAGS_max_in_nodes;
+    param.max_leaf_nodes                = FLAGS_max_leaf_nodes;
+    param.distance_threshold            = FLAGS_distance_threshold;
+    param.seed                          = FLAGS_seed;
+    param.coreset_size                  = FLAGS_coreset_size;
+    param.radius                        = FLAGS_radius;
+    param.delta                         = FLAGS_delta;
+    param.beta                          = FLAGS_beta;
+    param.buf_size                      = FLAGS_buf_size;
+    param.alpha                         = FLAGS_alpha;
+    param.lambda                        = FLAGS_lambda;
+    param.clean_interval                = FLAGS_clean_interval;
+    param.min_weight                    = FLAGS_min_weight;
+    param.base                          = FLAGS_base;
+    param.cm                            = FLAGS_cm;
+    param.cl                            = FLAGS_cl;
+    param.grid_width                    = FLAGS_grid_width;
+    param.min_points                    = FLAGS_min_points;
+    param.epsilon                       = FLAGS_epsilon;
+    param.mu                            = FLAGS_mu;
+    param.num_last_arr                  = FLAGS_num_last_arr;
+    param.time_window                   = FLAGS_time_window;
+    param.num_online_clusters           = FLAGS_num_online_clusters;
+    param.delta_grid                    = FLAGS_delta_grid;
+    param.num_samples                   = FLAGS_num_samples;
+    param.landmark                      = FLAGS_landmark;
+    param.sliding                       = FLAGS_sliding;
+    param.outlier_distance_threshold    = FLAGS_outlier_distance_threshold;
+    param.outlier_cap                   = FLAGS_outlier_cap;
+    param.outlier_density_threshold     = FLAGS_outlier_density_threshold;
+    param.neighbor_distance             = FLAGS_neighbor_distance;
+    param.k                             = FLAGS_k;
+    param.arr_rate                      = FLAGS_arr_rate;
+    param.run_offline                   = FLAGS_run_offline;
+    param.run_eval                      = FLAGS_run_eval;
+    param.run_cmm                       = FLAGS_run_cmm;
+    param.run_pur                       = FLAGS_run_pur;
+    param.obj                           = (BenneObj)FLAGS_obj;
+    param.benne_threshold.dim           = FLAGS_dim_threshold;
+    param.benne_threshold.queue_size    = FLAGS_queue_size_threshold;
+    param.benne_threshold.variance      = FLAGS_variance_threshold;
+    param.benne_threshold.outliers_num  = FLAGS_outliers_num_threshold;
+    param.benne_threshold.outliers_dist = FLAGS_outliers_dist_threshold;
 
-    param.output_file = "results.txt";
     param.fast_source = true;
     param.store       = false;
 
-    std::vector<SESAME::PointPtr> input;
-    std::vector<SESAME::PointPtr> results;
-
-    // Create Spout.
-    SESAME::DataSourcePtr sourcePtr = GenericFactory::New<DataSource>(param);
-
-    // Directly load data from file. TODO: configure it to load from external
-    // sensors, e.g., HTTP.
-    BenchmarkUtils::loadData(param, sourcePtr);
-
-    // Create Sink.
-    SESAME::DataSinkPtr sinkPtr = GenericFactory::New<DataSink>(param);
-
-    // Create Algorithm.
-    SESAME::AlgorithmPtr algoPtr = SESAME::AlgorithmFactory::create(param);
-
-    param.Print();
-
-    // Run algorithm producing results.
-    auto res = BenchmarkUtils::runBenchmark(param, sourcePtr, sinkPtr, algoPtr);
-
-    res->Print();
-}
+    RunBenchmark(param);
+}
@@ -10,6 +10,7 @@
 
 #include "Algorithm/DataStructure/Point.hpp"
 #include "Algorithm/Param.hpp"
+#include "Evaluation/Evaluation.hpp"
 #include "Sinks/DataSink.hpp"
 #include "Timer/Timer.hpp"
 
@@ -35,31 +36,33 @@ class Algorithm
     virtual void Init()                              = 0;
     virtual void RunOnline(SESAME::PointPtr input)   = 0;
     virtual void RunOffline(SESAME::DataSinkPtr ptr) = 0;
+    void Insert(SESAME::PointPtr input){};
+    virtual void OutputOnline(std::vector<PointPtr> &centers){};
     void Store(std::string output_file, int dim, std::vector<PointPtr> results);
     Timer win_timer, ds_timer, out_timer, ref_timer, sum_timer, lat_timer, on_timer;
     param_t param;
     int cnt = 0;
     std::vector<int64> et;
-    void PrintPerf()
+    PerfRes GetPerf()
     {
-        cout << "win_us: " << win_timer.sum / 1000 << endl;
-        cout << "ds_us: " << ds_timer.sum / 1000 << endl;
-        cout << "out_us: " << out_timer.sum / 1000 << endl;
-        cout << "ref_us: " << ref_timer.sum / 1000 << endl;
-        auto sum = win_timer.sum + ds_timer.sum + out_timer.sum + ref_timer.sum;
-        cout << "sum_us: " << sum / 1000 << endl;
-        assert(param.num_points);
+        PerfRes res;
+        res.win_us = win_timer.sum / 1000;
+        res.ds_us  = ds_timer.sum / 1000;
+        res.out_us = out_timer.sum / 1000;
+        res.ref_us = ref_timer.sum / 1000;
+        res.sum_us = sum_timer.sum / 1000;
         if (et.size() == 5)
         {
-            cout << "on_20: " << et[0] / 1e6 << endl;
-            cout << "on_40: " << et[1] / 1e6 << endl;
-            cout << "on_60: " << et[2] / 1e6 << endl;
-            cout << "on_80: " << et[3] / 1e6 << endl;
-            cout << "on_100: " << et[4] / 1e6 << endl;
+            res.on_20  = et[0] / 1e6;
+            res.on_40  = et[1] / 1e6;
+            res.on_60  = et[2] / 1e6;
+            res.on_80  = et[3] / 1e6;
+            res.on_100 = et[4] / 1e6;
         }
-        cout << "lat_us: " << lat_timer.sum / 1e3 / param.num_points << endl;
-        cout << "et_s: " << on_timer.sum / 1e9 << endl;
-        cout << "qps: " << param.num_points * 1e9 / sum_timer.sum << endl;
+        res.lat_us = lat_timer.sum / 1e3 / param.num_points;
+        res.et_s   = on_timer.sum / 1e9;
+        res.qps    = param.num_points * 1e9 / sum_timer.sum;
+        return res;
     }
     void Count()
     {
 
@@ -0,0 +1,96 @@
+//
+// Created by tuidan on 2021/8/24.
+//
+
+#ifndef SESAME_INCLUDE_ALGORITHM_BENNE_HPP_
+#define SESAME_INCLUDE_ALGORITHM_BENNE_HPP_
+
+#include "Algorithm/Algorithm.hpp"
+#include "Algorithm/DesignAspect/Generic.hpp"
+#include "Algorithm/OfflineRefinement/KMeans.hpp"
+#include "Algorithm/WindowModel/LandmarkWindow.hpp"
+#include "Sinks/DataSink.hpp"
+#include "Utils/BenchmarkUtils.hpp"
+
+#include <utility>
+
+namespace SESAME
+{
+struct characteristics
+{
+    bool frequentDrift = false;
+    bool manyOutliers  = false;
+    bool highDimension = false;
+};
+
+enum windowSelection
+{
+    landmark = 0,
+    sliding  = 1,
+    damped   = 2
+};
+enum dataSelection
+{
+    MCs   = 0,
+    CFT   = 1,
+    CoreT = 2,
+    DPT   = 3,
+    Grids = 4,
+    AMS   = 5
+};
+enum outlierSelection
+{
+    OD   = 0,
+    NoOD = 1,
+    ODB  = 2,
+    ODT  = 3,
+    ODBT = 4
+};
+enum refineSelection
+{
+    Incre    = 0,
+    OneShot  = 1,
+    NoRefine = 2
+};
+class Benne : public Algorithm
+{
+public:
+    std::vector<PointPtr> queue_;
+    std::vector<PointPtr> materialized_centers;
+    // std::vector<PointPtr> centers;
+    BenneThreshold T;
+    bool ds_changed = false;
+    AlgorithmPtr algo;
+    BenneObj obj;
+    characteristics chara;
+    windowSelection windowSel;
+    dataSelection dataSel;
+    outlierSelection outlierSel;
+    refineSelection refineSel;
+    KMeans kmeans;
+    int first_algo;
+    size_t change_count = 0;
+    std::vector<std::pair<int, int>> change_log;
+    Timer mig_timer, det_timer;
+
+    using MicroClusters                = ClusteringFeaturesList;
+    static constexpr int INCRE_REF_CNT = 50000;
+
+    Benne(param_t &cmd_params);
+
+    ~Benne();
+
+    void Init() override;
+
+    void RunOnline(PointPtr input) override;
+
+    void RunOffline(DataSinkPtr sinkPtr) override;
+
+private:
+    void Train(const PointPtr &point);
+    int Infer(const SESAME::PointPtr &input);
+    void UpdateAlgo(int, int);
+};
+
+}  // namespace SESAME
+#endif  // SESAME_INCLUDE_ALGORITHM_BENNE_HPP_
@@ -13,7 +13,7 @@
 namespace SESAME
 {
 
-class BirchParameter : public AlgorithmParameters
+class BirchParameter : public SesameParam
 {
 public:
     int max_in_nodes;           // B
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`namespace SESAME`
`14`	`14`	`{`
`15`	`15`
`16`		`-class BirchParameter : public AlgorithmParameters`
	`16`	`+class BirchParameter : public SesameParam`
`17`	`17`	`{`
`18`	`18`	`public:`
`19`	`19`	`int max_in_nodes; // B`