bool any() const { return _flags; }
     bool any(Type flags) const { return (_flags & flags); }
-    bool all() const { return (~_flags); }
-    bool all(Type flags) const { return (_flags & flags) != flags; }
+    bool all() const { return !(~_flags); }
+    bool all(Type flags) const { return (_flags & flags) == flags; }
     bool none() const { return _flags == 0; }
     bool none(Type flags) const { return (_flags & flags) == 0; }
-    bool exact(Type flags) const { return _flags = flags; }
     void clear() { _flags = 0; }
     void clear(Type flags) { _flags &= ~flags; }
-    void reset(Type flags) { _flags = flags;}
     void set(Type flags) { _flags |= flags; }
-    void set(Type f, bool val) { _flags = (_flags & f) | (val ? f : 0); }
+    void set(Type f, bool val) { _flags = (_flags & ~f) | (val ? f : 0); }
     void
     update(Type flags, Type mask)
     {
 
      * supplied.
      */
     Packet(Request *_req, MemCmd _cmd, NodeID _dest)
-        :  cmd(_cmd), req(_req), data(NULL), addr(_req->paddr),
-           size(_req->size), dest(_dest), time(curTick), senderState(NULL)
+        :  flags(VALID_DST), cmd(_cmd), req(_req), data(NULL),
+           addr(_req->paddr), size(_req->size), dest(_dest), time(curTick),
+           senderState(NULL)
     {
+        if (req->flags.any(Request::VALID_PADDR))
+            flags.set(VALID_ADDR|VALID_SIZE);
     }
 
     /**
      * req.  this allows for overriding the size/addr of the req.
      */
     Packet(Request *_req, MemCmd _cmd, NodeID _dest, int _blkSize)
-        :  cmd(_cmd), req(_req), data(NULL),
+        :  flags(VALID_DST), cmd(_cmd), req(_req), data(NULL),
            addr(_req->paddr & ~(_blkSize - 1)), size(_blkSize), dest(_dest),
            time(curTick), senderState(NULL)
     {
+        if (req->flags.any(Request::VALID_PADDR))
+            flags.set(VALID_ADDR|VALID_SIZE);
     }
 
     /**
         assert(isRequest());
         origCmd = cmd;
         cmd = cmd.responseCommand();
-        if (flags.any(VALID_SRC)) {
-            dest = src;
-            flags.set(VALID_DST);
-            flags.clear(VALID_SRC);
-        } else {
-            flags.clear(VALID_DST);
-        }
+
+        dest = src;
+        flags.set(VALID_DST, flags.any(VALID_SRC));
+        flags.clear(VALID_SRC);
     }
 
     void
         if (flags.any(ARRAY_DATA))
             delete [] data;
         else if (flags.any(DYNAMIC_DATA))
-
             delete data;
 
         flags.clear(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA);
     allocate()
     {
         if (data) {
-            assert(flags.none(STATIC_DATA|DYNAMIC_DATA));
-        } else {
-            flags.set(DYNAMIC_DATA|ARRAY_DATA);
-            data = new uint8_t[getSize()];
+            assert(flags.any(STATIC_DATA|DYNAMIC_DATA));
+            return;
         }
+
+        assert(flags.none(STATIC_DATA|DYNAMIC_DATA));
+        flags.set(DYNAMIC_DATA|ARRAY_DATA);
+        data = new uint8_t[getSize()];
     }