@depup/node-memwatch 1.0.1-depup.0

package/src/heapdiff.cc

@@ -0,0 +1,351 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+#include <map>
+#include <string>
+#include <set>
+#include <vector>
+
+#include <stdlib.h> // abs()
+#include <time.h>   // time()
+
+#include "heapdiff.hh"
+#include "util.hh"
+
+using namespace v8;
+using namespace node;
+using namespace std;
+
+static bool s_inProgress = false;
+static time_t s_startTime;
+
+bool heapdiff::HeapDiff::InProgress()
+{
+    return s_inProgress;
+}
+
+heapdiff::HeapDiff::HeapDiff() : ObjectWrap(), before(NULL), after(NULL),
+                                 ended(false)
+{
+}
+
+heapdiff::HeapDiff::~HeapDiff()
+{
+    if (before) {
+        ((HeapSnapshot *) before)->Delete();
+        before = NULL;
+    }
+
+    if (after) {
+        ((HeapSnapshot *) after)->Delete();
+        after = NULL;
+    }
+}
+
+void
+heapdiff::HeapDiff::Initialize ( v8::Handle<v8::Object> target )
+{
+    Nan::HandleScope scope;
+
+    v8::Local<v8::FunctionTemplate> t = Nan::New<v8::FunctionTemplate>(New);
+    t->InstanceTemplate()->SetInternalFieldCount(1);
+    t->SetClassName(Nan::New<v8::String>("HeapDiff").ToLocalChecked());
+
+    Nan::SetPrototypeMethod(t, "end", End);
+
+    target->Set(Nan::New<v8::String>("HeapDiff").ToLocalChecked(), t->GetFunction());
+}
+
+NAN_METHOD(heapdiff::HeapDiff::New)
+{
+    // Don't blow up when the caller says "new require('memwatch').HeapDiff()"
+    // issue #30
+    // stolen from: https://github.com/kkaefer/node-cpp-modules/commit/bd9432026affafd8450ecfd9b49b7dc647b6d348
+    if (!info.IsConstructCall()) {
+        return Nan::ThrowTypeError("Use the new operator to create instances of this object.");
+    }
+
+    Nan::HandleScope scope;
+
+    // allocate the underlying c++ class and wrap it up in the this pointer
+    HeapDiff * self = new HeapDiff();
+    self->Wrap(info.This());
+
+    // take a snapshot and save a pointer to it
+    s_inProgress = true;
+    s_startTime = time(NULL);
+
+#if (NODE_MODULE_VERSION >= 0x002D)
+    self->before = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(NULL);
+#else
+#if (NODE_MODULE_VERSION > 0x000B)
+    self->before = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(Nan::New<v8::String>("").ToLocalChecked(), NULL);
+#else
+    self->before = v8::HeapProfiler::TakeSnapshot(Nan::New<v8::String>("").ToLocalChecked(), HeapSnapshot::kFull, NULL);
+#endif
+#endif
+
+    s_inProgress = false;
+
+    info.GetReturnValue().Set(info.This());
+}
+
+static string handleToStr(const Local<Value> & str)
+{
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+
+	String::Utf8Value utfString(isolate, str->ToString());
+
+	return *utfString;
+}
+
+static void
+buildIDSet(set<uint64_t> * seen, const HeapGraphNode* cur, int & s)
+{
+    Nan::HandleScope scope;
+
+    // cycle detection
+    if (seen->find(cur->GetId()) != seen->end()) {
+        return;
+    }
+    // always ignore HeapDiff related memory
+    if (cur->GetType() == HeapGraphNode::kObject &&
+        handleToStr(cur->GetName()).compare("HeapDiff") == 0)
+    {
+        return;
+    }
+
+    // update memory usage as we go
+#if (NODE_MODULE_VERSION >= 0x002D)
+    s += cur->GetShallowSize();
+#else
+    s += cur->GetSelfSize();
+#endif
+    seen->insert(cur->GetId());
+
+    for (int i=0; i < cur->GetChildrenCount(); i++) {
+        buildIDSet(seen, cur->GetChild(i)->GetToNode(), s);
+    }
+}
+
+typedef set<uint64_t> idset;
+
+// why doesn't STL work?
+// XXX: improve this algorithm
+void setDiff(idset a, idset b, vector<uint64_t> &c)
+{
+    for (idset::iterator i = a.begin(); i != a.end(); i++) {
+        if (b.find(*i) == b.end()) c.push_back(*i);
+    }
+}
+
+
+class example
+{
+public:
+    HeapGraphEdge::Type context;
+    HeapGraphNode::Type type;
+    std::string name;
+    std::string value;
+    std::string heap_value;
+    int self_size;
+    int retained_size;
+    int retainers;
+
+    example() : context(HeapGraphEdge::kHidden),
+                type(HeapGraphNode::kHidden),
+                self_size(0), retained_size(0), retainers(0) { };
+};
+
+class change
+{
+public:
+    long int size;
+    long int added;
+    long int released;
+    std::vector<example> examples;
+
+    change() : size(0), added(0), released(0) { }
+};
+
+typedef std::map<std::string, change>changeset;
+
+static void manageChange(changeset & changes, const HeapGraphNode * node, bool added)
+{
+    std::string type;
+
+    switch(node->GetType()) {
+        case HeapGraphNode::kArray:
+            type.append("Array");
+            break;
+        case HeapGraphNode::kString:
+            type.append("String");
+            break;
+        case HeapGraphNode::kObject:
+            type.append(handleToStr(node->GetName()));
+            break;
+        case HeapGraphNode::kCode:
+            type.append("Code");
+            break;
+        case HeapGraphNode::kClosure:
+            type.append("Closure");
+            break;
+        case HeapGraphNode::kRegExp:
+            type.append("RegExp");
+            break;
+        case HeapGraphNode::kHeapNumber:
+            type.append("Number");
+            break;
+        case HeapGraphNode::kNative:
+            type.append("Native");
+            break;
+        case HeapGraphNode::kHidden:
+        default:
+            return;
+    }
+
+    if (changes.find(type) == changes.end()) {
+        changes[type] = change();
+    }
+
+    changeset::iterator i = changes.find(type);
+
+#if (NODE_MODULE_VERSION >= 0x002D)
+    i->second.size += node->GetShallowSize() * (added ? 1 : -1);
+#else
+    i->second.size += node->GetSelfSize() * (added ? 1 : -1);
+#endif
+    if (added) i->second.added++;
+    else i->second.released++;
+
+    // XXX: example
+
+    return;
+}
+
+static Handle<Value> changesetToObject(changeset & changes)
+{
+    Nan::EscapableHandleScope scope;
+    Local<Array> a = Nan::New<v8::Array>();
+
+    for (changeset::iterator i = changes.begin(); i != changes.end(); i++) {
+        Local<Object> d = Nan::New<v8::Object>();
+        d->Set(Nan::New("what").ToLocalChecked(), Nan::New(i->first.c_str()).ToLocalChecked());
+        d->Set(Nan::New("size_bytes").ToLocalChecked(), Nan::New<v8::Number>(i->second.size));
+        d->Set(Nan::New("size").ToLocalChecked(), Nan::New(mw_util::niceSize(i->second.size).c_str()).ToLocalChecked());
+        d->Set(Nan::New("+").ToLocalChecked(), Nan::New<v8::Number>(i->second.added));
+        d->Set(Nan::New("-").ToLocalChecked(), Nan::New<v8::Number>(i->second.released));
+        a->Set(a->Length(), d);
+    }
+
+    return scope.Escape(a);
+}
+
+
+static v8::Local<Value>
+compare(const v8::HeapSnapshot * before, const v8::HeapSnapshot * after)
+{
+    Nan::EscapableHandleScope scope;
+    int s, diffBytes;
+
+    Local<Object> o = Nan::New<v8::Object>();
+
+    // first let's append summary information
+    Local<Object> b = Nan::New<v8::Object>();
+    b->Set(Nan::New("nodes").ToLocalChecked(), Nan::New(before->GetNodesCount()));
+    //b->Set(Nan::New("time"), s_startTime);
+    o->Set(Nan::New("before").ToLocalChecked(), b);
+
+    Local<Object> a = Nan::New<v8::Object>();
+    a->Set(Nan::New("nodes").ToLocalChecked(), Nan::New(after->GetNodesCount()));
+    //a->Set(Nan::New("time"), time(NULL));
+    o->Set(Nan::New("after").ToLocalChecked(), a);
+
+    // now let's get allocations by name
+    set<uint64_t> beforeIDs, afterIDs;
+    s = 0;
+    buildIDSet(&beforeIDs, before->GetRoot(), s);
+    b->Set(Nan::New("size_bytes").ToLocalChecked(), Nan::New(s));
+    b->Set(Nan::New("size").ToLocalChecked(), Nan::New(mw_util::niceSize(s).c_str()).ToLocalChecked());
+
+    diffBytes = s;
+    s = 0;
+    buildIDSet(&afterIDs, after->GetRoot(), s);
+    a->Set(Nan::New("size_bytes").ToLocalChecked(), Nan::New(s));
+    a->Set(Nan::New("size").ToLocalChecked(), Nan::New(mw_util::niceSize(s).c_str()).ToLocalChecked());
+
+    diffBytes = s - diffBytes;
+
+    Local<Object> c = Nan::New<v8::Object>();
+    c->Set(Nan::New("size_bytes").ToLocalChecked(), Nan::New(diffBytes));
+    c->Set(Nan::New("size").ToLocalChecked(), Nan::New(mw_util::niceSize(diffBytes).c_str()).ToLocalChecked());
+    o->Set(Nan::New("change").ToLocalChecked(), c);
+
+    // before - after will reveal nodes released (memory freed)
+    vector<uint64_t> changedIDs;
+    setDiff(beforeIDs, afterIDs, changedIDs);
+    c->Set(Nan::New("freed_nodes").ToLocalChecked(), Nan::New<v8::Number>(changedIDs.size()));
+
+    // here's where we'll collect all the summary information
+    changeset changes;
+
+    // for each of these nodes, let's aggregate the change information
+    for (unsigned long i = 0; i < changedIDs.size(); i++) {
+        const HeapGraphNode * n = before->GetNodeById(changedIDs[i]);
+        manageChange(changes, n, false);
+    }
+
+    changedIDs.clear();
+
+    // after - before will reveal nodes added (memory allocated)
+    setDiff(afterIDs, beforeIDs, changedIDs);
+
+    c->Set(Nan::New("allocated_nodes").ToLocalChecked(), Nan::New<v8::Number>(changedIDs.size()));
+
+    for (unsigned long i = 0; i < changedIDs.size(); i++) {
+        const HeapGraphNode * n = after->GetNodeById(changedIDs[i]);
+        manageChange(changes, n, true);
+    }
+
+    c->Set(Nan::New("details").ToLocalChecked(), changesetToObject(changes));
+
+    return scope.Escape(o);
+}
+
+NAN_METHOD(heapdiff::HeapDiff::End)
+{
+    // take another snapshot and compare them
+    Nan::HandleScope scope;
+
+    HeapDiff *t = Unwrap<HeapDiff>( info.This() );
+
+    // How shall we deal with double .end()ing?  The only reasonable
+    // approach seems to be an exception, cause nothing else makes
+    // sense.
+    if (t->ended) {
+        return Nan::ThrowError("attempt to end() a HeapDiff that was already ended");
+    }
+    t->ended = true;
+
+    s_inProgress = true;
+#if (NODE_MODULE_VERSION >= 0x002D)
+    t->after = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(NULL);
+#else
+#if (NODE_MODULE_VERSION > 0x000B)
+    t->after = v8::Isolate::GetCurrent()->GetHeapProfiler()->TakeHeapSnapshot(Nan::New<v8::String>("").ToLocalChecked(), NULL);
+#else
+    t->after = v8::HeapProfiler::TakeSnapshot(Nan::New<v8::String>("").ToLocalChecked(), HeapSnapshot::kFull, NULL);
+#endif
+#endif
+    s_inProgress = false;
+
+    v8::Local<Value> comparison = compare(t->before, t->after);
+    // free early, free often.  I mean, after all, this process we're in is
+    // probably having memory problems.  We want to help her.
+    ((HeapSnapshot *) t->before)->Delete();
+    t->before = NULL;
+    ((HeapSnapshot *) t->after)->Delete();
+    t->after = NULL;
+
+    info.GetReturnValue().Set(comparison);
+}

package/src/heapdiff.hh

@@ -0,0 +1,34 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+
+#ifndef __HEADDIFF_H
+#define __HEADDIFF_H
+
+#include <v8.h>
+#include <v8-profiler.h>
+#include <node.h>
+#include <nan.h>
+
+namespace heapdiff
+{
+    class HeapDiff : public Nan::ObjectWrap
+    {
+      public:
+        static void Initialize ( v8::Handle<v8::Object> target );
+
+        static NAN_METHOD(New);
+        static NAN_METHOD(End);
+        static bool InProgress();
+
+      protected:
+        HeapDiff();
+        ~HeapDiff();
+      private:
+        const v8::HeapSnapshot * before;
+        const v8::HeapSnapshot * after;
+        bool ended;
+    };
+};
+
+#endif

package/src/init.cc

@@ -0,0 +1,26 @@
+/*
+ * 2012|lloyd|do what the fuck you want to
+ */
+
+#include <v8.h>
+#include <node.h>
+
+#include "heapdiff.hh"
+#include "memwatch.hh"
+
+extern "C" {
+    void init (v8::Handle<v8::Object> target)
+    {
+        v8::Isolate * isolate = target->GetIsolate();
+
+        Nan::HandleScope scope;
+        heapdiff::HeapDiff::Initialize(target);
+
+        Nan::SetMethod(target, "upon_gc", memwatch::upon_gc);
+        Nan::SetMethod(target, "gc", memwatch::trigger_gc);
+
+        isolate->AddGCEpilogueCallback(memwatch::after_gc);
+    }
+
+    NODE_MODULE(memwatch, init);
+};

package/src/memwatch.cc

@@ -0,0 +1,263 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+
+#include "platformcompat.hh"
+#include "memwatch.hh"
+#include "heapdiff.hh"
+#include "util.hh"
+
+#include <node.h>
+#include <node_version.h>
+
+#include <string>
+#include <cstring>
+#include <sstream>
+
+#include <math.h> // for pow
+#include <time.h> // for time
+
+using namespace v8;
+using namespace node;
+
+Handle<Object> g_context;
+Nan::Callback *g_cb;
+
+struct Baton {
+    uv_work_t req;
+    size_t heapUsage;
+    GCType type;
+    GCCallbackFlags flags;
+};
+
+static const unsigned int RECENT_PERIOD = 10;
+static const unsigned int ANCIENT_PERIOD = 120;
+
+static struct
+{
+    // counts of different types of gc events
+    unsigned int gc_full;
+    unsigned int gc_inc;
+    unsigned int gc_compact;
+
+    // last base heap size as measured *right* after GC
+    unsigned int last_base;
+
+    // the estimated "base memory" usage of the javascript heap
+    // over the RECENT_PERIOD number of GC runs
+    unsigned int base_recent;
+
+    // the estimated "base memory" usage of the javascript heap
+    // over the ANCIENT_PERIOD number of GC runs
+    unsigned int base_ancient;
+
+    // the most extreme values we've seen for base heap size
+    unsigned int base_max;
+    unsigned int base_min;
+
+    // leak detection!
+
+    // the period from which this leak analysis starts
+    time_t leak_time_start;
+    // the base memory for the detection period
+    time_t leak_base_start;
+    // the number of consecutive compactions for which we've grown
+    unsigned int consecutive_growth;
+} s_stats;
+
+static Local<Value> getLeakReport(size_t heapUsage)
+{
+    Nan::EscapableHandleScope scope;
+
+    size_t growth = heapUsage - s_stats.leak_base_start;
+    int now = time(NULL);
+    int delta = now - s_stats.leak_time_start;
+
+    Local<Object> leakReport = Nan::New<v8::Object>();
+    //leakReport->Set(Nan::New("start").ToLocalChecked(), NODE_UNIXTIME_V8(s_stats.leak_time_start));
+    //leakReport->Set(Nan::New("end").ToLocalChecked(), NODE_UNIXTIME_V8(now));
+    leakReport->Set(Nan::New("growth").ToLocalChecked(), Nan::New<v8::Number>(growth));
+
+    std::stringstream ss;
+    ss << "heap growth over 5 consecutive GCs ("
+       << mw_util::niceDelta(delta) << ") - "
+       << mw_util::niceSize(growth / ((double) delta / (60.0 * 60.0))) << "/hr";
+
+    leakReport->Set(Nan::New("reason").ToLocalChecked(), Nan::New(ss.str().c_str()).ToLocalChecked());
+
+    return scope.Escape(leakReport);
+}
+
+static void AsyncMemwatchAfter(uv_work_t* request) {
+    Nan::HandleScope scope;
+
+    Baton * b = (Baton *) request->data;
+
+    // do the math in C++, permanent
+    // record the type of GC event that occured
+    if (b->type == kGCTypeMarkSweepCompact) s_stats.gc_full++;
+    else s_stats.gc_inc++;
+
+    if (
+#if NODE_VERSION_AT_LEAST(0,8,0)
+        b->type == kGCTypeMarkSweepCompact
+#else
+        b->flags == kGCCallbackFlagCompacted
+#endif
+        ) {
+        // leak detection code.  has the heap usage grown?
+        if (s_stats.last_base < b->heapUsage) {
+            if (s_stats.consecutive_growth == 0) {
+                s_stats.leak_time_start = time(NULL);
+                s_stats.leak_base_start = b->heapUsage;
+            }
+
+            s_stats.consecutive_growth++;
+
+            // consecutive growth over 5 GCs suggests a leak
+            if (s_stats.consecutive_growth >= 5) {
+                // reset to zero
+                s_stats.consecutive_growth = 0;
+
+                // emit a leak report!
+                Local<Value> argv[3];
+                argv[0] = Nan::New<v8::Boolean>(false);
+                // the type of event to emit
+                argv[1] = Nan::New("leak").ToLocalChecked();
+                argv[2] = getLeakReport(b->heapUsage);
+
+                Nan::AsyncResource async("nan:Callback:Call");
+                g_cb->Call(3, argv, &async);
+            }
+        } else {
+            s_stats.consecutive_growth = 0;
+        }
+
+        // update last_base
+        s_stats.last_base = b->heapUsage;
+
+        // update compaction count
+        s_stats.gc_compact++;
+
+        // the first ten compactions we'll use a different algorithm to
+        // dampen out wider memory fluctuation at startup
+        if (s_stats.gc_compact < RECENT_PERIOD) {
+            double decay = pow(s_stats.gc_compact / RECENT_PERIOD, 2.5);
+            decay *= s_stats.gc_compact;
+            if (ISINF(decay) || ISNAN(decay)) decay = 0;
+            s_stats.base_recent = ((s_stats.base_recent * decay) +
+                                   s_stats.last_base) / (decay + 1);
+
+            decay = pow(s_stats.gc_compact / RECENT_PERIOD, 2.4);
+            decay *= s_stats.gc_compact;
+            s_stats.base_ancient = ((s_stats.base_ancient * decay) +
+                                    s_stats.last_base) /  (1 + decay);
+
+        } else {
+            s_stats.base_recent = ((s_stats.base_recent * (RECENT_PERIOD - 1)) +
+                                   s_stats.last_base) / RECENT_PERIOD;
+            double decay = FMIN(ANCIENT_PERIOD, s_stats.gc_compact);
+            s_stats.base_ancient = ((s_stats.base_ancient * (decay - 1)) +
+                                    s_stats.last_base) / decay;
+        }
+
+        // only record min/max after 3 gcs to let initial instability settle
+        if (s_stats.gc_compact >= 3) {
+            if (!s_stats.base_min || s_stats.base_min > s_stats.last_base) {
+                s_stats.base_min = s_stats.last_base;
+            }
+
+            if (!s_stats.base_max || s_stats.base_max < s_stats.last_base) {
+                s_stats.base_max = s_stats.last_base;
+            }
+        }
+
+        // if there are any listeners, it's time to emit!
+        if (!g_cb->IsEmpty()) {
+            Local<Value> argv[3];
+            // magic argument to indicate to the callback all we want to know is whether there are
+            // listeners (here we don't)
+            argv[0] = Nan::New<v8::Boolean>(true);
+
+            //Handle<Value> haveListeners = g_cb->call(1, argv);
+
+
+            double ut= 0.0;
+            if (s_stats.base_ancient) {
+                ut = (double) ROUND(((double) (s_stats.base_recent - s_stats.base_ancient) /
+                                      (double) s_stats.base_ancient) * 1000.0) / 10.0;
+            }
+
+            // ok, there are listeners, we actually must serialize and emit this stats event
+            Local<Object> stats = Nan::New<v8::Object>();
+            stats->Set(Nan::New("num_full_gc").ToLocalChecked(), Nan::New(s_stats.gc_full));
+            stats->Set(Nan::New("num_inc_gc").ToLocalChecked(), Nan::New(s_stats.gc_inc));
+            stats->Set(Nan::New("heap_compactions").ToLocalChecked(), Nan::New(s_stats.gc_compact));
+            stats->Set(Nan::New("usage_trend").ToLocalChecked(), Nan::New(ut));
+            stats->Set(Nan::New("estimated_base").ToLocalChecked(), Nan::New(s_stats.base_recent));
+            stats->Set(Nan::New("current_base").ToLocalChecked(), Nan::New(s_stats.last_base));
+            stats->Set(Nan::New("min").ToLocalChecked(), Nan::New(s_stats.base_min));
+            stats->Set(Nan::New("max").ToLocalChecked(), Nan::New(s_stats.base_max));
+            argv[0] = Nan::New<v8::Boolean>(false);
+            // the type of event to emit
+            argv[1] = Nan::New("stats").ToLocalChecked();
+            argv[2] = stats;
+
+            Nan::AsyncResource async("nan:Callback:Call");
+            g_cb->Call(3, argv, &async);
+        }
+    }
+
+    delete b;
+}
+
+static void noop_work_func(uv_work_t *) { }
+
+void memwatch::after_gc(Isolate* isolate, GCType type, GCCallbackFlags flags)
+{
+    if (heapdiff::HeapDiff::InProgress()) return;
+
+    Nan::HandleScope scope;
+
+    Baton * baton = new Baton;
+    v8::HeapStatistics hs;
+
+    Nan::GetHeapStatistics(&hs);
+
+    baton->heapUsage = hs.used_heap_size();
+    baton->type = type;
+    baton->flags = flags;
+    baton->req.data = (void *) baton;
+
+    // schedule our work to run in a moment, once gc has fully completed.
+    //
+    // here we pass a noop work function to work around a flaw in libuv,
+    // uv_queue_work on unix works fine, but will will crash on
+    // windows.  see: https://github.com/joyent/libuv/pull/629
+    uv_queue_work(uv_default_loop(), &(baton->req),
+		  noop_work_func, (uv_after_work_cb)AsyncMemwatchAfter);
+}
+
+NAN_METHOD(memwatch::upon_gc) {
+    Nan::HandleScope scope;
+    if (info.Length() >= 1 && info[0]->IsFunction()) {
+        g_cb = new Nan::Callback(info[0].As<v8::Function>());
+    }
+    info.GetReturnValue().Set(Nan::Undefined());
+}
+
+NAN_METHOD(memwatch::trigger_gc) {
+    Nan::HandleScope scope;
+    int deadline_in_ms = 500;
+    if (info.Length() >= 1 && info[0]->IsNumber()) {
+    		deadline_in_ms = (int)(info[0]->Int32Value());
+    }
+#if (NODE_MODULE_VERSION >= 0x002D)
+    Nan::IdleNotification(deadline_in_ms);
+    Nan::LowMemoryNotification();
+#else
+    while(!Nan::IdleNotification(deadline_in_ms)) {};
+    Nan::LowMemoryNotification();
+#endif
+    info.GetReturnValue().Set(Nan::Undefined());
+}

package/src/memwatch.hh

@@ -0,0 +1,18 @@
+/*
+ * 2012|lloyd|http://wtfpl.org
+ */
+
+#ifndef __MEMWATCH_HH
+#define __MEMWATCH_HH
+
+#include <node.h>
+#include <nan.h>
+
+namespace memwatch
+{
+    NAN_METHOD(upon_gc);
+    NAN_METHOD(trigger_gc);
+    void after_gc(v8::Isolate* isolate, v8::GCType type, v8::GCCallbackFlags flags);
+};
+
+#endif