- implemented a new wider interface in which the python object is transferred directly
authorFilippo Gioachin <gioachin@illinois.edu>
Thu, 19 Aug 2004 08:11:58 +0000 (08:11 +0000)
committerFilippo Gioachin <gioachin@illinois.edu>
Thu, 19 Aug 2004 08:11:58 +0000 (08:11 +0000)
  to the user code, thus allowing a greater flexibility.
- code cleanup.
- added the creation of a new interpreter every time a python code is executed, in this
  way it will be possible to have multiple threads running (for smp codes).
- TODO: the variable "pyNumber" is currently fixed, and must be updated for real
  multithreading

src/libs/ck-libs/pythonCCS/PythonCCS.C
src/libs/ck-libs/pythonCCS/PythonCCS.ci
src/libs/ck-libs/pythonCCS/PythonCCS.h

index 3def43be29fbefe407436cdebfc1c7bc99cc9a3f..78dba784c34670d2f3899a5420cd1f76922f7ce9 100644 (file)
@@ -11,13 +11,6 @@ PythonMain::PythonMain (CkArgMsg *msg) {
 CsvStaticDeclare(CmiNodeLock, pyLock);
 CsvStaticDeclare(PythonTable *, pyWorkers);
 CsvStaticDeclare(int, pyNumber);
-/*
-CkpvStaticDeclare(PythonChare *, curWorkerChare);
-CkpvStaticDeclare(PythonGroup *, curWorkerGroup);
-CkpvStaticDeclare(PythonNodeGroup *, curWorkerNodeGroup);
-CkpvStaticDeclare(PythonArray1D *, curWorkerArray1D);
-CkpvStaticDeclare(PythonArray2D *, curWorkerArray2D);
-*/
 
 // One-time per-processor setup routine
 // main interface for python to access common charm methods
@@ -41,7 +34,9 @@ static PyObject *CkPy_numpes(PyObject *self, PyObject *args) {
 
 static PyObject *CkPy_myindex(PyObject *self, PyObject *args) {
   if (!PyArg_ParseTuple(args, ":myindex")) return NULL;
-  PythonArray1D *pyArray;
+  CmiLock(CsvAccess(pyLock));
+  PythonArray1D *pyArray = dynamic_cast<PythonArray1D*>((*CsvAccess(pyWorkers))[0]);
+  CmiUnlock(CsvAccess(pyLock));
   if ((pyArray = (dynamic_cast<PythonArray1D*>((*CsvAccess(pyWorkers))[0])))) return Py_BuildValue("i", pyArray->thisIndex);
   else { Py_INCREF(Py_None);return Py_None;}
   //return Py_BuildValue("i", (*CsvAccess(pyWorkers))[0]->thisIndex);
@@ -49,32 +44,21 @@ static PyObject *CkPy_myindex(PyObject *self, PyObject *args) {
 
 // method to read a variable and convert it to a python object
 static PyObject *CkPy_read(PyObject *self, PyObject *args) {
-  char * str;
-  if (!PyArg_ParseTuple(args, "s:read", str)) return NULL;
-  std::string cstr = str;
+  if (!PyArg_ParseTuple(args, "O:read")) return NULL;
+  CmiLock(CsvAccess(pyLock));
   PythonObject *pyWorker = (*CsvAccess(pyWorkers))[0];
-  TypedValue result = pyWorker->read(cstr);
-  switch (result.type) {
-  case PY_INT:
-    return Py_BuildValue("i", result.value.i);
-
-  case PY_LONG:
-    return Py_BuildValue("l", result.value.l);
-  case PY_FLOAT:
-    return Py_BuildValue("f", result.value.f);
-  case PY_DOUBLE:
-    return Py_BuildValue("d", result.value.d);
-  }
+  CmiUnlock(CsvAccess(pyLock));
+  return pyWorker->read(args);
 }
 
 // method to convert a python object into a variable and write it
 static PyObject *CkPy_write(PyObject *self, PyObject *args) {
-  char * str;
-  PyObject *obj;
-  if (!PyArg_ParseTuple(args, "sO:write", &str, &obj)) return NULL;
-  std::string cstr = str;
-  Py_types varType = (*CsvAccess(pyWorkers))[0]->getType(cstr);
-  (*CsvAccess(pyWorkers))[0]->write(cstr, TypedValue(varType, obj));
+  PyObject *where, *what;
+  if (!PyArg_ParseTuple(args, "OO:write",&where,&what)) return NULL;
+  CmiLock(CsvAccess(pyLock));
+  PythonObject *pyWorker = (*CsvAccess(pyWorkers))[0];
+  CmiUnlock(CsvAccess(pyLock));
+  pyWorker->write(where, what);
   Py_INCREF(Py_None);return Py_None;
 }
 
@@ -93,59 +77,15 @@ void PythonObject::execute (CkCcsRequestMsg *msg) {
   CmiLock(CsvAccess(pyLock));
   //CsvAccess(pyWorkers)[++CsvAccess(pyNumber)] = this;
   (*CsvAccess(pyWorkers))[CsvAccess(pyNumber)] = this;
-  PyThreadState *pts = Py_NewInterpreter();
-  Py_InitModule("ck", CkPy_MethodsDefault);
-  PyRun_SimpleString((char *)msg->data);
-  Py_EndInterpreter(pts);
   CmiUnlock(CsvAccess(pyLock));
-}
-/*
-void PythonChare::execute (CkCcsRequestMsg *msg) {
-  CkPrintf("executing chare script\n");
-  CsvAccess(curWorkerChare)=this;
+  PyEval_AcquireLock();
   PyThreadState *pts = Py_NewInterpreter();
   Py_InitModule("ck", CkPy_MethodsDefault);
   PyRun_SimpleString((char *)msg->data);
   Py_EndInterpreter(pts);
+  PyEval_ReleaseLock();
 }
 
-void PythonGroup::execute (CkCcsRequestMsg *msg) {
-  CkPrintf("executing group script\n");
-  CsvAccess(curWorkerGroup)=this;
-  PyThreadState *pts = Py_NewInterpreter();
-  Py_InitModule("ck", CkPy_MethodsDefault);
-  PyRun_SimpleString((char *)msg->data);
-  Py_EndInterpreter(pts);
-}
-
-void PythonNodeGroup::execute (CkCcsRequestMsg *msg) {
-  CkPrintf("executing node group script\n");
-  CsvAccess(curWorkerNodeGroup)=this;
-  PyThreadState *pts = Py_NewInterpreter();
-  Py_InitModule("ck", CkPy_MethodsDefault);
-  PyRun_SimpleString((char *)msg->data);
-  Py_EndInterpreter(pts);
-}
-
-void PythonArray1D::execute (CkCcsRequestMsg *msg) {
-  CkPrintf("executing array 1D script\n");
-  CsvAccess(curWorkerArray1D)=this;
-  //PyThreadState *pts = Py_NewInterpreter();
-  //Py_InitModule("ck", CkPy_MethodsDefault);
-  PyRun_SimpleString((char *)msg->data);
-  //Py_EndInterpreter(pts);
-}
-
-void PythonArray2D::execute (CkCcsRequestMsg *msg) {
-  CkPrintf("executing array2D script\n");
-  CsvAccess(curWorkerArray2D)=this;
-  PyThreadState *pts = Py_NewInterpreter();
-  Py_InitModule("ck", CkPy_MethodsDefault);
-  PyRun_SimpleString((char *)msg->data);
-  Py_EndInterpreter(pts);
-}
-*/
-
 static void initializePythonDefault(void) {
   CsvInitialize(int, pyNumber);
   CsvAccess(pyNumber) = 0;
@@ -154,20 +94,9 @@ static void initializePythonDefault(void) {
   CsvInitialize(CmiNodeLock, pyLock);
   CsvAccess(pyLock) = CmiCreateLock();
 
-  /*
-  CkpvInitialize(PythonChare *,curWorkerChare);
-  CkpvInitialize(PythonGroup *,curWorkerGroup);
-  CkpvInitialize(PythonNodeGroup *,curWorkerNodeGroup);
-  CkpvInitialize(PythonArray1D *,curWorkerArray1D);
-  CkpvInitialize(PythonArray2D *,curWorkerArray2D);
-  CkpvAccess(curWorkerChare)=NULL;
-  CkpvAccess(curWorkerGroup)=NULL;
-  CkpvAccess(curWorkerNodeGroup)=NULL;
-  CkpvAccess(curWorkerArray1D)=NULL;
-  CkpvAccess(curWorkerArray2D)=NULL;
-  */
-
   Py_Initialize();
+  PyEval_InitThreads();
+  PyEval_ReleaseLock();
   PyObject *ck = Py_InitModule("ck", CkPy_MethodsDefault);
 }
 
index ba7fb6a7be86555dfdaccf5fe67150a1175d1bd5..2e85fd6d95d3f7e064d64f5efe42b714baec9e21 100644 (file)
@@ -31,5 +31,10 @@ module PythonCCS {
                entry void execute (CkCcsRequestMsg *msg);
        }
 
+       array [3D] PythonArray3D {
+               entry PythonArray3D(void);
+               entry void execute (CkCcsRequestMsg *msg);
+       }
+
        initnode void initializePythonDefault(void);
 }
index 50ad365ceed8eed2ed836c0c539100beb4e0a907..fc2118f37f9325bf97266e50360ef8a364730a43 100644 (file)
@@ -17,6 +17,7 @@ class PythonMain : public Chare {
 //#define PY_FLOAT   2
 //#define PY_DOUBLE  3
 
+/*
 enum Py_types {PY_INT, PY_LONG, PY_FLOAT, PY_DOUBLE};
 enum Py_objects {PY_CHARE, PY_GROUP, PY_NODEGROUP, PY_ARRAY1D, PY_ARRAY2D};
 
@@ -60,6 +61,7 @@ typedef struct TypedValue_ {
     }
   }
 } TypedValue;
+*/
 
 class PythonObject {
  public:
@@ -67,9 +69,8 @@ class PythonObject {
   void execute(CkCcsRequestMsg *msg);
 
   // the following three methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
+  virtual PyObject* read(PyObject*) {CkAbort("PythonCCS: Method read should be reimplemented");};
+  virtual void write(PyObject*, PyObject*) {CkAbort("PythonCCS: Method write should be reimplemented");};
   //virtual void registerPython();
 };
 
@@ -79,73 +80,34 @@ class PythonChare : public Chare, public PythonObject {
  public:
   PythonChare() {}
   PythonChare(CkMigrateMessage *msg) {}
-  //void execute(CkCcsRequestMsg *msg);
-
-  /*
-  // the following two methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
-  //virtual void registerPython();
-  */
 };
 
 class PythonGroup : public Group, public PythonObject {
  public:
   PythonGroup() {}
   PythonGroup(CkMigrateMessage *msg) {}
-  //void execute(CkCcsRequestMsg *msg);
-
-  /*
-  // the following three methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
-  //virtual void registerPython();
-  */
 };
 
 class PythonNodeGroup : public NodeGroup, public PythonObject {
  public:
   PythonNodeGroup() {}
   PythonNodeGroup(CkMigrateMessage *msg) {}
-  //void execute(CkCcsRequestMsg *msg);
-
-  /*
-  // the following two methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
-  //virtual void registerPython();
-  */
 };
 
 class PythonArray1D : public CBase_PythonArray1D, public PythonObject {
  public:
   PythonArray1D() {}
   PythonArray1D(CkMigrateMessage *msg) {}
-  //void execute(CkCcsRequestMsg *msg);
-
-  /*
-  // the following two methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
-  //virtual void registerPython();
-  */
 };
 
 class PythonArray2D : public CBase_PythonArray2D, public PythonObject {
  public:
   PythonArray2D() {}
   PythonArray2D(CkMigrateMessage *msg) {}
-  //void execute(CkCcsRequestMsg *msg);
+};
 
-  /*
-  // the following two methods should be overwritten by the user
-  virtual TypedValue read(std::string) {CkAbort("PythonCCS: Method read should be reimplemented");};
-  virtual void write(std::string, TypedValue) {CkAbort("PythonCCS: Method write should be reimplemented");};
-  virtual Py_types getType(std::string) {CkAbort("PythonCCS: Method getType should be reimplemented");};
-  //virtual void registerPython();
-  */
+class PythonArray3D : public CBase_PythonArray3D, public PythonObject {
+ public:
+  PythonArray3D() {}
+  PythonArray3D(CkMigrateMessage *msg) {}
 };