almost done with qthreads addition, need to dad better preemption, adding process/thread/pool selector at same time

Author: jonathan-beard

raftinc/kpair.hpp

@@ -24,6 +24,7 @@
 #include "kset.tcc"
 #include "portorder.hpp"
 #include "defs.hpp"
+#include "raftmanip.hpp"
 
 namespace raft
 {
@@ -135,6 +136,9 @@ 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 >> ( kpair &a, const raft::parallel::type &&type );
+kpair&  operator >> ( raft::kernel &a, const raft::parallel::type &&type );
+
 kpair& operator <= ( raft::kernel &a, raft::kernel  &b );
 kpair& operator <= ( raft::kernel &&a, raft::kernel &&b );
 kpair& operator <= ( raft::kernel &a,  kpair &b );

raftinc/raftmanip.hpp

@@ -0,0 +1,39 @@
+/**
+ * raftmanip.hpp - 
+ * @author: Jonathan Beard
+ * @version: Tue Aug 16 09:56:56 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 _RAFTMANIP_HPP_
+#define _RAFTMANIP_HPP_  1
+
+namespace raft
+{
+    namespace parallel
+    {
+        enum type { thread  /** specify a thread for each kernel **/, 
+                    pool    /** thread pool, one kernel thread per core, many kernels in each **/, 
+                    process /** open a new process from this point **/ };
+    }
+    namespace vm
+    {
+        enum type { flat        /** not yet implemented **/, 
+                    standard    /** threads share VM space, processes have sep **/, 
+                    partition   /** partition graph at this point into a new VM space, platform dependent **/ }; 
+    }
+} /** end namespace raft **/
+
+#endif /* END _RAFTMANIP_HPP_ */

raftmanip

@@ -0,0 +1,25 @@
+/**
+ * raftmanip.hpp - 
+ * @author: Jonathan Beard
+ * @version: Tue Aug 16 10:12:22 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 _RAFTMANIP_HPP_
+#define _RAFTMANIP_HPP_  1
+
+#include ./raftinc/raftmanip.hpp
+
+#endif /* END _RAFTMANIP_HPP_ */

src/kpair.cpp

@@ -182,6 +182,20 @@ operator >> ( ROoOkpair &a, raft::kernel &&b )
     return( *ptr );
 }
 
+//FIXME
+kpair&
+operator >> ( kpair &a, const raft::parallel::type &&type )
+{
+    kpair *ptr( nullptr );
+    return( *ptr );
+}
+
+kpair&  
+operator >> ( raft::kernel &a, const raft::parallel::type &&type )
+{
+
+}
+
 
 kpair&
 operator <= ( raft::kernel &a, raft::kernel &b )

testsuite/poolThreadRaftManip.cpp

@@ -0,0 +1,147 @@
+/**
+ * allocateSendPush.cpp - throw an error if internal object
+ * pop fails.
+ *
+ * @author: Jonathan Beard
+ * @version: Sat Feb 27 19:10:26 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 <cstdint>
+#include <cstdio>
+#include <cstddef>
+#include <raft>
+#include <raftmanip>
+#include <cstdlib>
+#include <cassert>
+
+
+template < std::size_t N > struct foo
+{
+   foo() : length( N ){}
+
+   foo( const foo &other ) : length( other.length )
+   {
+        using index_type = std::remove_const_t<decltype(N)>;
+        for( index_type i( 0 ); i < N; i++ )
+        {
+            pad[ i ] = other.pad[ i ];
+        }
+   }
+
+   ~foo() = default;
+
+   int length;
+   int pad[ N ];
+};
+
+using obj_t = foo< 80 >;
+
+class start : public raft::kernel
+{
+public:
+    start() : raft::kernel()
+    {
+        output.addPort< obj_t >( "y" );
+    }
+
+    virtual ~start() = default;
+
+    virtual raft::kstatus run()
+    {
+        auto &mem( output[ "y" ].allocate< obj_t >() );
+        for( auto i( 0 ); i < mem.length; i++ )
+        {
+            mem.pad[ i ] = static_cast< int >( counter );
+        }
+        output[ "y" ].send();
+        counter++;
+        if( counter == 200 )
+        {
+            return( raft::stop );
+        }
+        return( raft::proceed );
+    }
+
+private:
+    std::size_t counter = 0;
+};
+
+
+class middle : public raft::kernel
+{
+public:
+    middle() : raft::kernel()
+    {
+        input.addPort< obj_t >( "x" );
+        output.addPort< obj_t >( "y" );
+    }
+
+    virtual raft::kstatus run()
+    {
+        auto &val( input[ "x" ].peek< obj_t >() );
+        output[ "y" ].push( val );
+        input[ "x" ].unpeek();
+        input[ "x" ].recycle( 1 );
+        return( raft::proceed );
+    }
+};
+
+
+class last : public raft::kernel
+{
+public:
+    last() : raft::kernel()
+    {
+        input.addPort< obj_t >( "x" );
+    }
+
+    virtual ~last() = default;
+
+    virtual raft::kstatus run()
+    {
+        obj_t mem;
+        input[ "x" ].pop( mem );
+        /** Jan 2016 - otherwise end up with a signed/unsigned compare w/auto **/
+        using index_type = std::remove_const_t< decltype( mem.length ) >;
+        for( index_type i( 0 ); i < mem.length; i++ )
+        {
+            //will fail if we've messed something up
+            if( static_cast< std::size_t >( mem.pad[ i ] ) != counter )
+            {
+                std::cerr << "failed test\n"; 
+                exit( EXIT_FAILURE );
+            }
+        }
+        counter++;
+        return( raft::proceed );
+    }
+
+private:
+    std::size_t counter = 0;
+};
+
+int
+main()
+{
+    start s;
+    last l;
+    middle m;
+
+    raft::map M;
+    M += s >> m >> raft::parallel::thread >> l;
+    M.exe();
+    return( EXIT_SUCCESS );
+}