Changeset 15031

Timestamp:

07/02/08 06:14:19 (6 months ago)

Author:

hayamiz

Message:

lang/cplusplus/minipy/trunk: マルチスレッド,mutex,cond var実装完了.サンプルとしてhttpサーバーも実装

Location:

lang/cplusplus/minipy/trunk

Files:

• bootstrap.inc (modified) (2 diffs)
• etc/gen_bootstrap.rb (modified) (1 diff)
• native.cpp (modified) (1 diff)
• native.hpp (modified) (2 diffs)
• pyvalues.cpp (modified) (5 diffs)
• pyvalues.hpp (modified) (7 diffs)
• testdata-parser/thread/basic.py (modified) (2 diffs)
• testdata-parser/thread/httpserver.py (added)
• testdata-parser/thread/queue.py (added)
• thread.hpp (added)
• tivi.cpp (modified) (2 diffs)

lang/cplusplus/minipy/trunk/bootstrap.inc

@@ -1 +1 @@
 /* !! DO NOT EDIT THIS FILE !! */
-/* this file was generated by etc/gen_bootstrap.rb @ Tue Jul 01 17:13:28 +0900 2008 */
+/* this file was generated by etc/gen_bootstrap.rb @ Wed Jul 02 05:40:47 +0900 2008 */
 genv.set_sym(Symbol::get("is_int"), Py_val::mk_nfun(Symbol::get("is_int"), 1, native::is_int));
 genv.set_sym(Symbol::get("is_float"), Py_val::mk_nfun(Symbol::get("is_float"), 1, native::is_float));
@@ -92 +92 @@
 genv.set_sym(Symbol::get("ntv_random"), Py_val::mk_nfun(Symbol::get("ntv_random"), -1, native::ntv_random));
 genv.set_sym(Symbol::get("sys_sleep"), Py_val::mk_nfun(Symbol::get("sys_sleep"), 1, native::sys_sleep));
+genv.set_sym(Symbol::get("mutex"), Py_val::mk_nfun(Symbol::get("mutex"), 0, native::mutex));
+genv.set_sym(Symbol::get("lock"), Py_val::mk_nfun(Symbol::get("lock"), 1, native::lock));
+genv.set_sym(Symbol::get("unlock"), Py_val::mk_nfun(Symbol::get("unlock"), 1, native::unlock));
+genv.set_sym(Symbol::get("condition"), Py_val::mk_nfun(Symbol::get("condition"), 1, native::condition));
+genv.set_sym(Symbol::get("acquire"), Py_val::mk_nfun(Symbol::get("acquire"), 1, native::acquire));
+genv.set_sym(Symbol::get("release"), Py_val::mk_nfun(Symbol::get("release"), 1, native::release));
+genv.set_sym(Symbol::get("wait"), Py_val::mk_nfun(Symbol::get("wait"), 1, native::wait));
+genv.set_sym(Symbol::get("notify"), Py_val::mk_nfun(Symbol::get("notify"), 1, native::notify));
+genv.set_sym(Symbol::get("notifyAll"), Py_val::mk_nfun(Symbol::get("notifyAll"), 1, native::notifyAll));
+genv.set_sym(Symbol::get("get_rawaddr"), Py_val::mk_nfun(Symbol::get("get_rawaddr"), 1, native::get_rawaddr));
+genv.set_sym(Symbol::get("make_sockaddr"), Py_val::mk_nfun(Symbol::get("make_sockaddr"), 1, native::make_sockaddr));
+genv.set_sym(Symbol::get("py_socket"), Py_val::mk_nfun(Symbol::get("py_socket"), 0, native::py_socket));
+genv.set_sym(Symbol::get("py_bind"), Py_val::mk_nfun(Symbol::get("py_bind"), 2, native::py_bind));
+genv.set_sym(Symbol::get("py_listen"), Py_val::mk_nfun(Symbol::get("py_listen"), 1, native::py_listen));
+genv.set_sym(Symbol::get("py_accept"), Py_val::mk_nfun(Symbol::get("py_accept"), 2, native::py_accept));
+genv.set_sym(Symbol::get("py_recv"), Py_val::mk_nfun(Symbol::get("py_recv"), 1, native::py_recv));
+genv.set_sym(Symbol::get("py_send"), Py_val::mk_nfun(Symbol::get("py_send"), 2, native::py_send));
+genv.set_sym(Symbol::get("py_close"), Py_val::mk_nfun(Symbol::get("py_close"), 1, native::py_close));

lang/cplusplus/minipy/trunk/etc/gen_bootstrap.rb

@@ -99 +99 @@
                 [:ntv_random, -1],
                 [:sys_sleep, 1],
+
+                [:mutex, 0],
+                [:lock, 1],
+                [:unlock, 1],
+
+                [:condition, 1],
+                [:acquire, 1],
+                [:release, 1],
+                [:wait, 1],
+                [:notify, 1],
+                [:notifyAll, 1],
+
+                [:get_rawaddr, 1],
+
+                [:make_sockaddr, 1],
+                [:py_socket, 0],
+                [:py_bind, 2],
+                [:py_listen, 1],
+                [:py_accept, 2],
+                [:py_recv, 1],
+                [:py_send, 2],
+                [:py_close, 1],
                ]
 

lang/cplusplus/minipy/trunk/native.cpp

@@ -1512 +1512 @@
     return ret;
 }
+
+py_val_t native::mutex(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                   py_val_t * a){
+    return Py_val::mk_mutex();
+}
+
+py_val_t native::lock(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                   py_val_t * a){
+    if(!Py_val::is_mutex(a[0])){
+        runtime_error(bt, p, "type error : lock() requires mutex.");
+    }
+
+    PTH_ASSERT(pthread_mutex_lock(&a[0]->u.mutex->mutex));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::unlock(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                   py_val_t * a){
+    if(!Py_val::is_mutex(a[0])){
+        runtime_error(bt, p, "type error : unlock() requires mutex.");
+    }
+
+    PTH_ASSERT(pthread_mutex_unlock(&a[0]->u.mutex->mutex));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::condition(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                           py_val_t * a){
+    
+    if (!Py_val::is_mutex(a[0])){
+        runtime_error(bt, p, "type error : condition() requires mutex.");
+    }
+
+    return Py_val::mk_cond(a[0]);
+}
+
+py_val_t native::acquire(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    if(!Py_val::is_cond(a[0])){
+        runtime_error(bt, p, "type error : acquire() requires condition value.");
+    }
+
+    PTH_ASSERT(pthread_mutex_lock(&a[0]->u.cond->py_mutex->u.mutex->mutex));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::release(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    if(!Py_val::is_cond(a[0])){
+        runtime_error(bt, p, "type error : release() requires condition value.");
+    }
+
+    PTH_ASSERT(pthread_mutex_unlock(&a[0]->u.cond->py_mutex->u.mutex->mutex));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::wait(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+
+    if(!(Py_val::is_cond(a[0]))){
+        runtime_error(bt, p, "type error : wait() requires condition value and mutex.");
+    }
+
+    PTH_ASSERT(pthread_cond_wait(&a[0]->u.cond->cond
+                                 , &a[0]->u.cond->py_mutex->u.mutex->mutex));
+    
+    return Py_val::mk_none();
+}
+
+py_val_t native::notify(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    if(!(Py_val::is_cond(a[0]))){
+        runtime_error(bt, p, "type error : notify() requires condiiton value.");
+    }
+
+    PTH_ASSERT(pthread_cond_signal(&a[0]->u.cond->cond));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::notifyAll(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    if(!(Py_val::is_cond(a[0]))){
+        runtime_error(bt, p, "type error : notifyAll() requires condition value.");
+    }
+
+    PTH_ASSERT(pthread_cond_broadcast(&a[0]->u.cond->cond));
+
+    return Py_val::mk_none();
+}
+
+py_val_t native::make_sockaddr(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : make_sockaddr() requires integer as port number.");
+    }
+    return Py_val::mk_sockaddr(a[0]);
+}
+
+py_val_t native::py_socket(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a){
+    int fd = socket(AF_INET, SOCK_STREAM, 0);
+    
+    return Py_val::mk_int(fd);
+}
+
+py_val_t native::py_bind(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                      py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : bind() requires integer as socket.");
+    }
+    if (!Py_val::is_sockaddr(a[1])){
+        runtime_error(bt, p, "type error : bind() requires sockaddr.");
+    }
+
+    int ret = bind(getint(a[0]), (struct sockaddr *)a[1]->u.addr
+                   ,sizeof(*a[1]->u.addr));
+    return Py_val::mk_int(ret);
+}
+
+py_val_t native::py_listen(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                      py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : listen() requires integer as socket.");
+    }
+
+    int ret = listen(getint(a[0]), 64);
+    return Py_val::mk_int(ret);
+}
+
+py_val_t native::py_accept(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                        py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : accept() requires integer as socket.");
+    }
+    if (!Py_val::is_sockaddr(a[1])){
+        runtime_error(bt, p, "type error : accept() requires sockaddr.");
+    }
+
+    socklen_t socklen;
+    int conn_fd = accept(getint(a[0])
+                         , (struct sockaddr *)a[1]->u.addr
+                         , &socklen);
+
+    return Py_val::mk_int(conn_fd);
+}
+
+py_val_t native::py_recv(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                      py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : recv() requires integer as connection file discriptor.");
+    }
+    
+    char buf[4096];
+    int len = recv(getint(a[0]), buf, 4096, 0);
+
+    if (len < 0){
+        runtime_error(bt, p, "recv error");
+        exit(1);
+    }
+
+    string str(buf);
+    return Py_val::mk_string(str);
+}
+
+py_val_t native::py_send(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                      py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : send() requires integer as connection file discriptor.");
+    }
+    if (!Py_val::is_string(a[1])){
+        runtime_error(bt, p, "type error : send() requires string.");
+    }
+
+    return Py_val::mk_int(send(getint(a[0]), a[1]->u.s->c_str(), a[1]->u.s->length(), 0));
+}
+
+py_val_t native::py_close(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                      py_val_t * a){
+    if (!Py_val::is_int(a[0])){
+        runtime_error(bt, p, "type error : close() requires integer as connection file discriptor.");
+    }
+
+    return Py_val::mk_int(close(getint(a[0])));
+}
+
+py_val_t native::get_rawaddr(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                             py_val_t * a){
+    return Py_val::mk_int((int) a[0]);
+}
+
+

lang/cplusplus/minipy/trunk/native.hpp

@@ -10 +10 @@
 #include "env.hpp"
 #include "tivi.hpp"
+
+#include <arpa/inet.h>
+#include <sys/socket.h>
+
+#define DEFINE_PY_FUNC(funcname)                                \
+    py_val_t funcname(ConsStack<Stack_trace_entry*> * bt        \
+                      ,const SrcPos & p,                        \
+                      py_val_t * a)
 
 namespace native{
@@ -246 +254 @@
 
     // experimental multithread implementation
+    py_val_t mutex(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                   py_val_t * a);
+    py_val_t lock(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a);
+    py_val_t unlock(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                    py_val_t * a);
+
+    py_val_t condition(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a);
+    py_val_t acquire(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a);
+    py_val_t release(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a);
+    py_val_t wait(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                  py_val_t * a);
+    py_val_t notify(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                    py_val_t * a);
+    py_val_t notifyAll(ConsStack<Stack_trace_entry*> * bt,const SrcPos & p,
+                       py_val_t * a);
+    DEFINE_PY_FUNC(get_rawaddr);
+
+    // networking
+    DEFINE_PY_FUNC(make_sockaddr);
+
+    DEFINE_PY_FUNC(py_socket);
+    DEFINE_PY_FUNC(py_bind);
+    DEFINE_PY_FUNC(py_listen);
+    DEFINE_PY_FUNC(py_accept);
+    DEFINE_PY_FUNC(py_recv);
+    DEFINE_PY_FUNC(py_send);
+    DEFINE_PY_FUNC(py_close);
 }
 

lang/cplusplus/minipy/trunk/pyvalues.cpp

@@ -584 +584 @@
                , (uint)pyval->u.n->f);
         break;
+    case py_type_thread:
+        printf("<thread>");
+        break;
     default:
         cerr << "never reaches here at " << __FILE__ << ":" << __LINE__; exit(1);
@@ -648 +651 @@
 bool Py_val::is_thread(py_val_t pyval){
     return is_boxed(pyval) && pyval->type == py_type_thread;
+}
+
+bool Py_val::is_mutex(py_val_t pyval){
+    return is_boxed(pyval) && pyval->type == py_type_mutex;
+}
+
+bool Py_val::is_cond(py_val_t pyval){
+    return is_boxed(pyval) && pyval->type == py_type_cond;
+}
+
+bool Py_val::is_sockaddr(py_val_t pyval){
+    return is_boxed(pyval) && pyval->type == py_type_sockaddr;
 }
 
@@ -979 +994 @@
 
 
+py_val_t Py_val::mk_mutex(){
+    py_val_t ret;
+
+    ret = Py_val::alloc_boxed(py_type_mutex);
+    Py_mutex * mutex = new Py_mutex();
+    ret->u.mutex = mutex;
+
+    return ret;
+}
+
+
+py_val_t Py_val::mk_cond(py_val_t mutex){
+    py_val_t ret;
+
+    ret = Py_val::alloc_boxed(py_type_cond);
+    Py_cond * cond = new Py_cond(mutex);
+    ret->u.cond = cond;
+    
+    return ret;
+}
+
+py_val_t Py_val::mk_sockaddr(py_val_t port){
+    py_val_t ret;
+
+    ret = Py_val::alloc_boxed(py_type_sockaddr);
+    ret->u.addr = new sockaddr_in();
+    ret->u.addr->sin_family = AF_INET;
+    ret->u.addr->sin_addr.s_addr = htonl(INADDR_ANY);
+    ret->u.addr->sin_port = htons(getint(port));
+    
+    return ret;
+}
+
+
 /*
  * 辞書式!
@@ -1200 +1249 @@
     this->func = func;
     this->joined = false;
-    pthread_mutex_t mt = PTHREAD_MUTEX_INITIALIZER;
-    this->join_mutex = mt;
-    pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
-    this->join_cond = cnd;
+
+    // pthread_mutex_t mt = PTHREAD_MUTEX_INITIALIZER;
+//     this->join_mutex = mt;
+//     pthread_cond_t cnd = PTHREAD_COND_INITIALIZER;
+//     this->join_cond = cnd;
 
     PTH_ASSERT(pthread_mutex_init(&this->join_mutex, NULL));
@@ -1212 +1262 @@
     
 }
+
+Py_mutex::Py_mutex(){
+    pthread_mutex_init(&this->mutex, NULL);
+}
+
+Py_cond::Py_cond(py_val_t mutex){
+    this->py_mutex = mutex;
+    pthread_cond_init(&this->cond, NULL);
+}

lang/cplusplus/minipy/trunk/pyvalues.hpp

@@ -17 +17 @@
 #include "thread.hpp"
 
+#include <sys/socket.h>
+#include <netinet/in.h>
+
 class Py_val;
 class Py_ifun;
@@ -27 +30 @@
 class Py_tuple;
 class Py_thread;
+class Py_mutex;
+class Py_cond;
 
 /* stack trace */
@@ -95 +100 @@
     py_type_mutex,
     py_type_cond,
+    py_type_sockaddr,
 } py_type_t;
 
@@ -157 +163 @@
         Py_tuple * nl;  /* tuple or list(in the future) */
         Py_thread * th;
+        Py_mutex * mutex;
+        Py_cond * cond;
+        sockaddr_in * addr;
     } u;
 
@@ -176 +185 @@
     static bool is_number(py_val_t pyval); // is int or float
     static bool is_thread(py_val_t pyval);
+    static bool is_mutex(py_val_t pyval);
+    static bool is_cond(py_val_t pyval);
+    static bool is_sockaddr(py_val_t pyval);
 
     /* 型チェックをし、Py_val_tから値を取り出す.
@@ -219 +231 @@
     
     static py_val_t mk_thread(py_val_t func);
+    static py_val_t mk_mutex();
+    static py_val_t mk_cond(py_val_t mutex);
+
+    static py_val_t mk_sockaddr(py_val_t port);
 
 #define mkint(var) Py_val::mk_int(var)
@@ -378 +394 @@
 public:
     pthread_mutex_t mutex;
-    
-}
-
+
+    Py_mutex();
+};
+
+class Py_cond {
+public:
+    pthread_cond_t cond;
+    py_val_t py_mutex;
+
+    Py_cond(py_val_t mutex);
+};
 #endif

lang/cplusplus/minipy/trunk/testdata-parser/thread/basic.py

@@ -1 +1 @@
 
 x = 0
+lk = mutex()
 
 def job():
   global x
+  global lk
   for i in range(0,100000):
+    lk.lock()
     x = x + 1
+    y = y + 1
+    lk.unlock()
 
-th_a = start_new_thread(print_string, ("hoge",))
-th_b = start_new_thread(print_string, ("fuga",))
+th_a = start_new_thread(job, ())
+th_b = start_new_thread(job, ())
 
 thread_join(th_a)
@@ -14 +19 @@
 
 print x
+print y

lang/cplusplus/minipy/trunk/tivi.cpp

@@ -712 +712 @@
         if (INST == VM_GREF_CALL){
             if ((f = TIVI_GREF(TIVI_FETCH_OPERAND())) == py_val_not_found){
-                runtime_error("no such function ", bt, PC);
+                runtime_error("no such function " + *genv_rev[(int)TIVI_FETCH_OPERAND()], bt, PC);
             }
             bt = CONS_STACK(new Stack_trace_entry(*genv_rev[(int)this->insns[PC].operand]
@@ -1060 +1060 @@
     
     delete(args);
+
+    return NULL;
 }