Changeset fb2ce27

Timestamp:

Mar 8, 2018, 1:37:46 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

28bc8c8

Parents:

f1f8e55

Message:

Update all benchmarks to match new CFA

Location:

doc/papers/general/evaluation

Files:

• c-bench.c (modified) (3 diffs)
• c-stack.c (modified) (1 diff)
• cfa-stack.c (modified) (3 diffs)
• cpp-bench.cpp (modified) (1 diff)
• cpp-vbench.cpp (modified) (1 diff)
• cpp-vstack.cpp (modified) (1 diff)
• object.hpp (modified) (4 diffs)

doc/papers/general/evaluation/c-bench.c

@@ -5 +5 @@
 #include "c-stack.h"
 
-_Bool* new_bool( _Bool b ) {
-        _Bool* q = malloc(sizeof(_Bool)); /***/
-        *q = b;
+char* new_char( char c ) {
+        char* q = malloc(sizeof(char)); /***/
+        *q = c;
         return q;
 }
 
-char* new_char( char c ) {
-        char* q = malloc(sizeof(char)); /***/
-        *q = c;
+short* new_short( short s ) {
+        short* q = malloc(sizeof(short)); /***/
+        *q = s;
         return q;
 }
@@ -23 +23 @@
 }
 
-void* copy_bool( const void* p ) { return new_bool( *(const _Bool*)p ); } /***/
 void* copy_char( const void* p ) { return new_char( *(const char*)p ); } /***/
+void* copy_short( const void* p ) { return new_short( *(const short*)p ); } /***/
 void* copy_int( const void* p ) { return new_int( *(const int*)p ); } /***/
-void* copy_pair_bool_char( const void* p ) { return copy_pair( p, copy_bool, copy_char ); } /***/
-void free_pair_bool_char( void* p ) { free_pair( p, free, free ); } /***/
-
-int cmp_bool( const void* a, const void* b ) { /***/
-        return *(const _Bool*)a == *(const _Bool*)b ? 0 : *(const _Bool*)a < *(const _Bool*)b ? -1 : 1; 
-}
+void* copy_pair_short_char( const void* p ) { return copy_pair( p, copy_short, copy_char ); } /***/
+void free_pair_short_char( void* p ) { free_pair( p, free, free ); } /***/
 
 int cmp_char( const void* a, const void* b ) { /***/
         return *(const char*)a == *(const char*)b ? 0 : *(const char*)a < *(const char*)b ? -1 : 1;
+}
+
+int cmp_short( const void* a, const void* b ) { /***/
+        return *(const short*)a == *(const short*)b ? 0 : *(const short*)a < *(const short*)b ? -1 : 1; 
 }
 
@@ -49 +49 @@
                 free(xi); )
 
-        struct pair * maxp = new_pair( new_bool(0), new_char('\0') ),
-                * valp = new_pair( new_bool(1), new_char('a') );
+        struct pair * maxp = new_pair( new_short(0), new_char('\0') ),
+                * valp = new_pair( new_short(42), new_char('a') );
         struct stack sp = new_stack(), tp;
 
-        REPEAT_TIMED( "push_pair", N, push_stack( &sp, copy_pair_bool_char( valp ) ); )
-        TIMED( "copy_pair", copy_stack( &tp, &sp, copy_pair_bool_char ); /***/ )
-        TIMED( "clear_pair", clear_stack( &sp, free_pair_bool_char ); /***/ )
+        REPEAT_TIMED( "push_pair", N, push_stack( &sp, copy_pair_short_char( valp ) ); )
+        TIMED( "copy_pair", copy_stack( &tp, &sp, copy_pair_short_char ); /***/ )
+        TIMED( "clear_pair", clear_stack( &sp, free_pair_short_char ); /***/ )
         REPEAT_TIMED( "pop_pair", N, 
                 struct pair * xp = pop_stack( &tp );
-                if ( cmp_pair( xp, maxp, cmp_bool, cmp_char /***/ ) > 0 ) {
-                        free_pair_bool_char( maxp ); /***/
+                if ( cmp_pair( xp, maxp, cmp_short, cmp_char /***/ ) > 0 ) {
+                        free_pair_short_char( maxp ); /***/
                         maxp = xp;
                 } else {
-                        free_pair_bool_char( xp ); /***/
+                        free_pair_short_char( xp ); /***/
                 } )
-        free_pair_bool_char( maxp ); /***/
-        free_pair_bool_char( valp ); /***/
+        free_pair_short_char( maxp ); /***/
+        free_pair_short_char( valp ); /***/
 }

doc/papers/general/evaluation/c-stack.c

@@ -13 +13 @@
         for ( struct stack_node* next = t->head; next; next = next->next ) {
                 *crnt = malloc(sizeof(struct stack_node)); /***/
-                **crnt = (struct stack_node){ copy(next->value) }; /***/
+                (*crnt)->value = copy(next->value);
                 crnt = &(*crnt)->next;
         }
-        *crnt = 0;
+        *crnt = NULL;
 }
 

doc/papers/general/evaluation/cfa-stack.c

@@ -31 +31 @@
 
 forall(otype T) void push( stack(T) & s, T value ) with( s ) {
-        stack_node(T)* new_node = malloc();
-        (*new_node){ value, head };
-        head = new_node;
+        stack_node(T)* n = malloc();
+        (*n){ value, head };
+        head = n;
 }
 
@@ -39 +39 @@
         stack_node(T) * n = head;
         head = n->next;
-        T v = n->value;
+        T x = n->value;
         ^(*n){};
         free( n );
-        return v;
+        return x;
 }
 
@@ -52 +52 @@
                 free(crnt);
         }
-        s.head = 0;
+        head = 0;
 }

doc/papers/general/evaluation/cpp-bench.cpp

@@ -13 +13 @@
         REPEAT_TIMED( "pop_int", N, maxi = std::max( maxi, ti.pop() ); )
 
-        pair<bool, char> maxp = { false, '\0' }, valp = { true, 'a' };
-        stack<pair<bool, char>> sp, tp;
+        pair<short, char> maxp = { 0, '\0' }, valp = { 42, 'a' };
+        stack<pair<short, char>> sp, tp;
         
         REPEAT_TIMED( "push_pair", N, sp.push( valp ); )

doc/papers/general/evaluation/cpp-vbench.cpp

@@ -13 +13 @@
         REPEAT_TIMED( "pop_int", N, maxi = std::max( maxi, ti.pop()->as<integer>() ); /***/ )
 
-        ptr<pair> maxp = make<pair>( make<boolean>(false), make<character>('\0') );
-        pair valp{ make<boolean>(true), make<character>('a') };
+        ptr<pair> maxp = make<pair>( make<short_integer>(0), make<character>('\0') );
+        pair valp{ make<short_integer>(42), make<character>('a') };
         stack sp, tp;
         

doc/papers/general/evaluation/cpp-vstack.cpp

@@ -7 +7 @@
         node** crnt = &head;
         for ( node* next = o.head; next; next = next->next ) {
-                *crnt = new node{ *next->value };
+                *crnt = new node{ *next->value }; /***/
                 crnt = &(*crnt)->next;
         }

doc/papers/general/evaluation/object.hpp

@@ -67 +67 @@
 };
 
-class boolean : public ordered, public printable {
-        bool x;
-public:
-        boolean() = default;
-        boolean(bool x) : x(x) {}
-        boolean(const boolean&) = default;
-        boolean(boolean&&) = default;
-        ptr<object> new_inst() const override { return make<boolean>(); }
-        ptr<object> new_copy() const override { return make<boolean>(*this); }
-        boolean& operator= (const boolean& that) {
-                x = that.x;
-                return *this;   
-        }
-        object& operator= (const object& that) override { return *this = that.as<boolean>(); } /***/
-        boolean& operator= (boolean&&) = default;
-        ~boolean() override = default;
-
-        int cmp(const boolean& that) const { return x == that.x ? 0 : x == false ? -1 : 1; }
-        int cmp(const ordered& that) const override { return cmp( that.as<boolean>() ); } /***/
-
-        void print(std::ostream& out) const override { out << (x ? "true" : "false"); }
-};
-
 class character : public ordered, public printable {
         char x;
@@ -116 +93 @@
 };
 
+class short_integer : public ordered, public printable {
+        short x;
+public:
+        short_integer() = default;
+        short_integer(short x) : x(x) {}
+        short_integer(const short_integer&) = default;
+        short_integer(short_integer&&) = default;
+        ptr<object> new_inst() const override { return make<short_integer>(); }
+        ptr<object> new_copy() const override { return make<short_integer>(*this); }
+        short_integer& operator= (const short_integer& that) {
+                x = that.x;
+                return *this;   
+        }
+        object& operator= (const object& that) override { return *this = that.as<short_integer>(); } /***/
+        short_integer& operator= (short_integer&&) = default;
+        ~short_integer() override = default;
+
+        int cmp(const short_integer& that) const { return x == that.x ? 0 : x < that.x ? -1 : 1; }
+        int cmp(const ordered& that) const override { return cmp( that.as<short_integer>() ); } /***/
+
+        void print(std::ostream& out) const override { out << x; }
+};
+
 class integer : public ordered, public printable {
         int x;
@@ -137 +137 @@
 
         void print(std::ostream& out) const override { out << x; }
-};
-
-class c_string : public printable {
-        static constexpr const char* empty = "";
-        const char* s;
-public:
-        c_string() : s(empty) {}
-        c_string(const char* s) : s(s) {}
-        c_string(const c_string&) = default;
-        c_string(c_string&&) = default;
-        ptr<object> new_inst() const override { return make<c_string>(); }
-        ptr<object> new_copy() const override { return make<c_string>(s); }
-        c_string& operator= (const c_string& that) {
-                s = that.s;
-                return *this;
-        }
-        object& operator= (const object& that) override { return *this = that.as<c_string>(); } /***/
-        c_string& operator= (c_string&&) = default;
-        ~c_string() override = default;
-
-        void print(std::ostream& out) const override { out << s; }
 };
 
@@ -188 +167 @@
                 return y->as<ordered>().cmp( that.y->as<ordered>() ); /***/
         }
-        int cmp(const ordered& that) const override { return cmp( that.as<pair>() ); }
+        int cmp(const ordered& that) const override { return cmp( that.as<pair>() ); } /***/
 
         void print(std::ostream& out) const override {