almost finished with the iterator return type. need to test on a few more platforms, and with the qthreads compile flag on. ran into a bug in qthreads on a harpertown intel platform. will check out...appears to hang on a spinlock inside qthreads lib, will check in the AM.

jonathan-beard · jonathan-beard · commit cf49acedd6d5 · 2016-09-01T19:58:48.000-05:00
diff --git a/raftinc/kernel.hpp b/raftinc/kernel.hpp
@@ -29,6 +29,7 @@
 #include "port.hpp"
 #include "signalvars.hpp"
 #include "rafttypes.hpp"
+#include "kernel_wrapper.hpp"
 
 /** pre-declare for friends **/ 
 class MapBase;
@@ -85,11 +86,11 @@ class kernel
 
    template < class T /** kernel type **/,
                class ... Args >
-      static kernel* make( Args&&... params )
+      static kernel_wrapper make( Args&&... params )
       {
          auto *output( new T( std::forward< Args >( params )... ) );
          output->internal_alloc = true;
-         return( output );
+         return( kernel_wrapper( output ) );
       }
    
    /** 
diff --git a/raftinc/kernel_wrapper.hpp b/raftinc/kernel_wrapper.hpp
@@ -0,0 +1,101 @@
+/**
+ * kernel_wrapper.hpp - this class is designed to be used only by the kernel.hpp
+ * make kernel function. It's supposed to be a wrapper class for the kernel type
+ * and sub-types. It should ahve a destructor that destroys the wrapped pointer
+ * on scope exit if it hasn't already been deallocated (attempting to be extra 
+ * safe). Its main function is to provide a syntax marker for the operator >>
+ * overloads in the kpair.hpp file so that the compiler knows exactly what to 
+ * link to. The other reason for this class's existence is b/c we can't really 
+ * use the move syntax without a complicated copy. The kernel itself cannot live
+ * on the stack, it must live in the heap or elsewhere.
+ *
+ * @author: Jonathan Beard
+ * @version: Thu Sep  1 16:12:43 2016
+ * 
+ * Copyright 2016 Jonathan Beard
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef _KERNEL_WRAPPER_HPP_
+#define _KERNEL_WRAPPER_HPP_  1
+#include <cstdint>
+
+/** pre-declare kpair, header included in cpp file **/
+class kpair;
+
+namespace raft
+{
+
+/** pre-declare this one too, header in cpp file **/
+class kernel;
+
+class kernel_wrapper
+{
+    const static std::uintptr_t sentinel = 0x7070707070707070;
+public:
+    /**
+     * kernel_wrapper - copy constructor. Takes ownership
+     * of the kernel wrapped by other, sets other to the 
+     * sentinel value so that it no longer has a valid kernel
+     * to own, and it also prevents a double free.
+     * @param   other - const kernel_wrapper
+     */
+    kernel_wrapper( const kernel_wrapper &other );
+    
+    /** 
+     * destructor deletes stored kernel 
+     * if it exits scope...should exit
+     * scope if it's actually being used
+     */
+    virtual ~kernel_wrapper();
+
+    
+
+protected:
+    /**
+     * kernel_wrapper - constructor for the wrapper 
+     * object, this does exactly what it says and 
+     * sets the wrapper to the parameter kernel. 
+     * @param   k   - raft::kernel* const
+     */
+    kernel_wrapper( raft::kernel * const k ); 
+    
+    /**
+     * operator * - this function will be used by the 
+     * kpair object when it takes ownership of the 
+     * pointer. This will then be passed to the map
+     * object. The wrapped pointer will be set with
+     * the sentinal value so that it isn't double
+     * freed. 
+     * @return raft::kernel*
+     */
+    raft::kernel* operator * ();
+
+    
+    raft::kernel *k = reinterpret_cast< raft::kernel* >( sentinel );
+
+    /** 
+     * kernel will need to access the constructor for the
+     * static make function
+     */
+    friend class kernel;
+    /**
+     * kpair will need to access so it can get to the operator* 
+     * overload
+     */
+    friend class ::kpair;
+};
+
+}
+
+#endif /* END _KERNEL_WRAPPER_HPP_ */
diff --git a/raftinc/kpair.hpp b/raftinc/kpair.hpp
@@ -28,6 +28,7 @@
 namespace raft
 {
     class kernel;
+    class kernel_wrapper;
     class map;
 }
 
@@ -53,16 +54,41 @@ class kpair
            raft::kernel &b,
            const bool split,
            const bool join );
+    
+    kpair( raft::kernel &a, 
+           raft::kernel_wrapper &b,
+           const bool split,
+           const bool join );
+    
+    kpair( raft::kernel_wrapper &a, 
+           raft::kernel &b,
+           const bool split,
+           const bool join );
+    
+    kpair( raft::kernel_wrapper &a, 
+           raft::kernel_wrapper &b,
+           const bool split,
+           const bool join );
 
     kpair( kpair &a,
            raft::kernel  &b,
            const bool split,
            const bool join );
+    
+    kpair( kpair &a,
+           raft::kernel_wrapper  &b,
+           const bool split,
+           const bool join );
 
     kpair( raft::kernel &a,
            kpair        &n,
            const bool   split,
            const bool   join );
+    
+    kpair( raft::kernel_wrapper &a,
+           kpair        &n,
+           const bool   split,
+           const bool   join );
 
     kpair( kpair &a,
            kpair &b,
@@ -71,6 +97,15 @@ class kpair
 
     kpair( raft::kernel &a, raft::kernel &b );
     
+    kpair( raft::kernel &a, 
+           raft::kernel_wrapper &b );
+    
+    kpair( raft::kernel_wrapper &a, 
+           raft::kernel  &b );
+
+    kpair( raft::kernel_wrapper &a, 
+           raft::kernel_wrapper &b );
+    
     void setOoO() noexcept;
 
 protected:
@@ -91,44 +126,37 @@ class kpair
 
     bool          out_of_order  = false;
     friend class raft::map;
-    friend kpair& operator >= ( kpair &a, raft::kernel &&b );
-    friend kpair& operator >= ( kpair &a, raft::kernel &b );
-    friend kpair& operator <= ( raft::kernel &a, raft::kernel  &b );
-    friend kpair& operator <= ( raft::kernel &&a, raft::kernel &&b );
-    friend kpair& operator <= ( raft::kernel &a,  kpair &b );
-    friend kpair& operator <= ( raft::kernel &&a, kpair &b );
-    friend kpair& operator >= ( kpair &a, kpair &b );
-    friend kpair& operator >= ( raft::kernel &a, kpair &b );
-    friend kpair& operator >= ( raft::kernel &&a, kpair &b );
 };
 
 
 
 kpair& operator >> ( raft::kernel &a,  raft::kernel &b  );
-kpair& operator >> ( raft::kernel &&a, raft::kernel &&b );
+kpair& operator >> ( raft::kernel_wrapper &&a, raft::kernel_wrapper &&b );
+kpair& operator >> ( raft::kernel &a, raft::kernel_wrapper &&w );
+
 kpair& operator >> ( kpair &a, raft::kernel &b );
-kpair& operator >> ( kpair &a, raft::kernel &&b );
+kpair& operator >> ( kpair &a, raft::kernel_wrapper &&w );
 
 LOoOkpair& operator >> ( raft::kernel &a, const raft::order::spec &&order );
 kpair&     operator >> ( LOoOkpair &a, raft::kernel &b );
-kpair&     operator >> ( LOoOkpair &a, raft::kernel &&b );
+kpair&     operator >> ( LOoOkpair &a, raft::kernel_wrapper &&w );
 
 ROoOkpair& operator >> ( kpair &a, const raft::order::spec &&order );
 kpair&     operator >> ( ROoOkpair &a, raft::kernel &b );
-kpair&     operator >> ( ROoOkpair &a, raft::kernel &&b );
+kpair&     operator >> ( ROoOkpair &a, raft::kernel_wrapper &&w );
 
 
 kpair& operator <= ( raft::kernel &a, raft::kernel  &b );
-kpair& operator <= ( raft::kernel &&a, raft::kernel &&b );
+kpair& operator <= ( raft::kernel_wrapper &&a, raft::kernel_wrapper &&b );
 kpair& operator <= ( raft::kernel &a,  kpair &b );
-kpair& operator <= ( raft::kernel &&a, kpair &b );
+kpair& operator <= ( raft::kernel_wrapper &&w, kpair &b );
 
 kpair& operator >= ( kpair &a, raft::kernel &b );
-kpair& operator >= ( kpair &a, raft::kernel &&b );
+kpair& operator >= ( kpair &a, raft::kernel_wrapper &&w );
 kpair& operator >= ( kpair &a, kpair &b );
 
 kpair& operator >= ( raft::kernel &a, kpair &b );
-kpair& operator >= ( raft::kernel &&a, kpair &b );
+kpair& operator >= ( raft::kernel_wrapper &&w, kpair &b );
 
 
 #endif /* END _KPAIR_HPP_ */
diff --git a/src/kernel_wrapper.cpp b/src/kernel_wrapper.cpp
@@ -0,0 +1,63 @@
+/**
+ * kernel_wrapper.cpp - 
+ * @author: Jonathan Beard
+ * @version: Thu Sep  1 16:12:43 2016
+ * 
+ * Copyright 2016 Jonathan Beard
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "kernel_wrapper.hpp"
+#include "kernel.hpp"
+
+using namespace raft;
+
+kernel_wrapper::kernel_wrapper( raft::kernel * const k ) : k( k ){}
+
+kernel_wrapper::kernel_wrapper( const kernel_wrapper &other ) : k( other.k )
+{
+    /** 
+     * ensures other wrapper no longer valid, also prevents
+     * double free.
+     */
+    const_cast<kernel_wrapper&>( other ).k 
+        = reinterpret_cast< raft::kernel* >( kernel_wrapper::sentinel ); 
+}
+
+kernel_wrapper::~kernel_wrapper()
+{
+    /** 
+     * check for sentinal value, if it's there..then we don't need
+     * to delete this one as the map object already has ownership
+     */
+    if( reinterpret_cast< std::uintptr_t >( k ) != kernel_wrapper::sentinel )
+    {
+        delete( k );
+        /** 
+         * set sentinal value just in case this one happens to belong to two
+         * wrapper objects. It also helps to make sure you can't accidentally
+         * pass the map an invalid wrapped kernel
+         */
+        k = reinterpret_cast< raft::kernel* >( kernel_wrapper::sentinel );
+    }
+}
+
+raft::kernel* kernel_wrapper::operator *()
+
+
+{
+    auto * const ptr( k );
+    /** reset sentinel value so that the delete doesn't accidentally delete it **/
+    k = reinterpret_cast< raft::kernel* >( kernel_wrapper::sentinel );
+    return( ptr );
+}
diff --git a/src/kpair.cpp b/src/kpair.cpp
diff --git a/testsuite/partitionTest.cpp b/testsuite/partitionTest.cpp
