Fix pyscripter#441

True thread parallelism using the new emNewInterpreterOwnGIL thread execution mode in Python 12

Author: pyscripter

Demos/Demo33/SortThds.pas

@@ -1,11 +1,10 @@
 unit SortThds;
 
 
-
 interface
 
 uses
- Classes,
+ Types, Classes,
  Graphics, ExtCtrls, Forms,
  PythonEngine;
 
@@ -125,11 +124,11 @@ procedure TSortThread.ExecuteWithPython;
  try
  with GetPythonEngine do
  begin
- if Assigned(FModule) and (ThreadExecMode = emNewInterpreter) then
+ if Assigned(FModule) and (ThreadExecMode <> emNewState) then
  FModule.InitializeForNewInterpreter;
  if Assigned(fScript) then
  ExecStrings(fScript);
- pyfunc := FindFunction( ExecModule, fpyfuncname);
+ pyfunc := FindFunction(ExecModule, utf8encode(fpyfuncname));
  if Assigned(pyfunc) then
  try
  EvalFunction(pyfunc,[NativeInt(self),0,FSize]);
@@ -159,7 +158,7 @@ procedure TSortThread.Stop;
 function TSortThread.getvalue(i: integer): integer;
 begin
  if Terminated then
- raise EPythonError.Create( 'Pythonthread terminated');
+ raise EPythonError.Create('Pythonthread terminated');
  Result := FSortArray^[i];
 end;
 

Demos/Demo33/ThSort.pas

@@ -117,14 +117,17 @@ procedure TThreadSortForm.InitThreads(ThreadExecMode: TThreadExecMode; script: T
 
  Thread1 := TSortThread.Create( ThreadExecMode, script, SortModule, 'SortFunc1',
  BubbleSortBox, BubbleSortArray);
+ Thread1.InterpreterConfig := _PyInterpreterConfig_INIT;
  Thread1.OnTerminate := ThreadDone;
 
  Thread2 := TSortThread.Create( ThreadExecMode, script, SortModule, 'SortFunc2',
  SelectionSortBox, SelectionSortArray);
+ Thread2.InterpreterConfig := _PyInterpreterConfig_INIT;
  Thread2.OnTerminate := ThreadDone;
 
  Thread3 := TSortThread.Create( ThreadExecMode, script, SortModule, 'SortFunc3',
  QuickSortBox, QuickSortArray);
+ Thread3.InterpreterConfig := _PyInterpreterConfig_INIT;
  Thread3.OnTerminate := ThreadDone;
 
  end;
@@ -144,7 +147,7 @@ procedure TThreadSortForm.Start1BtnClick(Sender: TObject);
 
 procedure TThreadSortForm.Start3BtnClick(Sender: TObject);
 begin
- InitThreads(emNewInterpreter, PythonMemo.Lines);
+ InitThreads(emNewInterpreterOwnGIL, PythonMemo.Lines);
 //PythonEngine1.ExecStrings(PythonMemo.Lines);
 end;
 

Demos/Demo36/ParallelPython.dpr

@@ -0,0 +1,121 @@
+program ParallelPython;
+
+{$APPTYPE CONSOLE}
+
+{$R *.res}
+
+uses
+ System.SysUtils,
+ System.Diagnostics,
+ System.Variants,
+ System.SyncObjs,
+ PythonEngine,
+ VarPyth;
+
+var
+ PythonEngine: TPythonEngine;
+
+procedure CreatePyEngine;
+begin
+ PythonEngine := TPythonEngine.Create(nil);
+ PythonEngine.Name := 'PythonEngine';
+ PythonEngine.LoadDll;
+ TPythonThread.Py_Begin_Allow_Threads;
+end;
+
+procedure DestroyEngine;
+begin
+ TPythonThread.Py_End_Allow_Threads;
+ PythonEngine.Free;
+end;
+
+const
+ N = 5;
+ Script =
+ 'import math'#10 +
+ ''#10 +
+ 'def is_prime(n):'#10 +
+ ' """ totally naive implementation """'#10 +
+ ' if n <= 1:'#10 +
+ ' return False'#10 +
+ ''#10 +
+ ' q = math.floor(math.sqrt(n))'#10 +
+ ' for i in range(2, q + 1):'#10 +
+ ' if (n % i == 0):'#10 +
+ ' return False'#10 +
+ ' return True'#10 +
+ ''#10 +
+ ''#10 +
+ 'def count_primes(max_n):'#10 +
+ ' res = 0'#10 +
+ ' for i in range(2, max_n + 1):'#10 +
+ ' if is_prime(i):'#10 +
+ ' res += 1'#10 +
+ ' return res'#10 +
+ ''#10 +
+ 'print("prime count", count_primes(1000000))'#10 +
+ ''#10;
+
+var
+ Event: TCountdownEvent;
+
+type
+ TPyThread = class(TPythonThread)
+ protected
+ procedure ExecuteWithPython; override;
+ public
+ constructor Create(ThreadMode: TThreadExecMode);
+ end;
+
+procedure TPyThread.ExecuteWithPython;
+begin
+ GetPythonEngine.ExecString(Script);
+ Event.Signal;
+end;
+
+constructor TPyThread.Create(ThreadMode: TThreadExecMode);
+begin
+ inherited Create;
+ ThreadExecMode := ThreadMode;
+ FreeOnTerminate := True;
+ InterpreterConfig := _PyInterpreterConfig_INIT;
+end;
+
+var
+ SW: TStopwatch;
+ I: Integer;
+begin
+ try
+ CreatePyEngine;
+ try
+ Event := TCountdownEvent.Create(N);
+ WriteLn('Classic Subinterpreter:');
+ SW := TStopwatch.StartNew;
+ for I := 1 to N do
+ TPyThread.Create(emNewState);
+ Event.WaitFor;
+ Event.Free;
+ SW.Stop;
+ WriteLn('Elapsed ms: ' + SW.ElapsedMilliseconds.ToString);
+ WriteLn;
+
+ Event := TCountdownEvent.Create(N);
+ WriteLn('Subinterpreter with own GIL:');
+ SW := TStopwatch.StartNew;
+ for I := 1 to N do
+ TPyThread.Create(emNewInterpreterOwnGIL);
+ Event.WaitFor;
+ Event.Free;
+ SW.Stop;
+ WriteLn('Elapsed ms: ' + SW.ElapsedMilliseconds.ToString);
+ WriteLn;
+ finally
+ DestroyEngine;
+ end;
+ except
+ on E: Exception do
+ Writeln(E.ClassName, ': ', E.Message);
+ end;
+ ReadLn;
+end.
+

Demos/readme.txt

@@ -32,3 +32,4 @@ Demo32	Demo08 revisited using WrapDelphi
 Demo33 Using Threads inside Python
 Demo34 Dynamically creating, destroying and recreating PythonEngine. Uses PythonVersions
 Demo35 Fast access to numpy arrays using the buffer protocol
+Demo36 True thread parallelism using the new emNewInterpreterOwnGIL thread execution mode in Python 12

Source/PythonEngine.pas

@@ -956,28 +956,35 @@ PyBufferProcs = record
 
  //bytearrayobject.h
 
- //typedef struct {
- // PyObject_VAR_HEAD
- // Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */
- // char *ob_bytes; /* Physical backing buffer */
- // char *ob_start; /* Logical start inside ob_bytes */
- // Py_ssize_t ob_exports; /* How many buffer exports */
- //} PyByteArrayObject;
-
  PyByteArrayObject = {$IFDEF CPUX86}packed{$ENDIF} record
- // Start of PyObject_VAR_HEAD
- // Start of the Head of an object
- ob_base: PyObject;
- ob_size: Py_ssize_t;
- // End of the Head of an object
+ ob_refcnt: NativeInt;
+ ob_type: PPyTypeObject;
+ ob_alloc: Py_ssize_t;
  ob_bytes: PAnsiChar;
  ob_start: PAnsiChar;
  ob_exports: Py_ssize_t;
  end;
 
+ //initconfig.h
+
+const
+ _PyStatus_TYPE_OK = 0;
+ _PyStatus_TYPE_ERROR = 1;
+ _PyStatus_TYPE_EXIT = 2;
+
+type
+ TPyStatus_Type = Integer;
+
+ PyStatus = {$IFDEF CPUX86}packed{$ENDIF} record
+ _type: TPyStatus_Type;
+ func: PAnsiChar;
+ err_msg: PAnsiChar;
+ exitcode: Integer;
+ end;
+
 //#######################################################
 //## ##
-//## GIL state  ##
+//## GIL related ##
 //## ##
 //#######################################################
 const
@@ -986,12 +993,40 @@ PyBufferProcs = record
 type
  PyGILState_STATE = type Integer; // (PyGILState_LOCKED, PyGILState_UNLOCKED);
 
+ // Introduced in Python 12
+const
+ PyInterpreterConfig_DEFAULT_GIL = 0;
+ PyInterpreterConfig_SHARED_GIL = 1;
+ PyInterpreterConfig_OWN_GIL = 2;
+
+ type
+ PPyInterpreterConfig = ^PyInterpreterConfig;
+ PyInterpreterConfig = {$IFDEF CPUX86}packed{$ENDIF} record
+ use_main_obmalloc: Integer;
+ allow_fork: Integer;
+ allow_exec: Integer;
+ allow_threads: Integer;
+ allow_daemon_threads: Integer;
+ check_multi_interp_extensions: Integer;
+ gil: Integer;
+ end;
+
+const
+ _PyInterpreterConfig_INIT: PyInterpreterConfig =
+ ( use_main_obmalloc: 0;
+ allow_fork: 0;
+ allow_exec: 0;
+ allow_threads: 1;
+ allow_daemon_threads: 0;
+ check_multi_interp_extensions: 1;
+ gil: PyInterpreterConfig_OWN_GIL);
+
 //#######################################################
 //## ##
 //## New exception classes ##
 //## ##
 //#######################################################
-
+type
  // Components' exceptions
  EDLLLoadError = class(Exception);
  EDLLImportError = class(Exception)
@@ -1709,6 +1744,7 @@ TPythonInterface=class(TDynamicDll)
  Py_IsInitialized : function : integer; cdecl;
  Py_GetProgramFullPath : function : PAnsiChar; cdecl;
  Py_NewInterpreter : function : PPyThreadState; cdecl;
+ Py_NewInterpreterFromConfig : function( tstate: PPyThreadState; config: PPyInterpreterConfig): PyStatus; cdecl;
  Py_EndInterpreter : procedure( tstate: PPyThreadState); cdecl;
  PyEval_AcquireLock : procedure; cdecl;
  PyEval_ReleaseLock : procedure; cdecl;
@@ -2798,7 +2834,7 @@ TPyVar = class(TPyObject)
 //## Thread Object with Python interpreter lock ##
 //## ##
 //#######################################################
- TThreadExecMode = (emNewState, emNewInterpreter);
+ TThreadExecMode = (emNewState, emNewInterpreter, emNewInterpreterOwnGIL);
 
 {$HINTS OFF}
  TPythonThread = class(TThread)
@@ -2813,6 +2849,7 @@ TPythonThread = class(TThread)
  protected
  procedure ExecuteWithPython; virtual; abstract;
  public
+ InterpreterConfig: PyInterpreterConfig;
  class procedure Py_Begin_Allow_Threads;
  class procedure Py_End_Allow_Threads;
  // The following procedures are redundant and only for
@@ -2863,6 +2900,7 @@ function SysVersionFromDLLName(const DLLFileName : string): string;
 procedure PythonVersionFromDLLName(LibName: string; out MajorVersion, MinorVersion: integer);
 function PythonVersionFromRegVersion(const ARegVersion: string;
  out AMajorVersion, AMinorVersion: integer): boolean;
+function PyStatus_Exception(const APyStatus: PyStatus): Boolean;
 
 { Helper functions}
 (*
@@ -3950,6 +3988,8 @@ procedure TPythonInterface.MapDll;
  Py_GetProgramFullPath := Import('Py_GetProgramFullPath');
  Py_GetBuildInfo := Import('Py_GetBuildInfo');
  Py_NewInterpreter := Import('Py_NewInterpreter');
+ if (FMajorVersion > 3) or (FMinorVersion >= 12) then
+ Py_NewInterpreterFromConfig := Import('Py_NewInterpreterFromConfig');
  Py_EndInterpreter := Import('Py_EndInterpreter');
  PyEval_AcquireLock := Import('PyEval_AcquireLock');
  PyEval_ReleaseLock := Import('PyEval_ReleaseLock');
@@ -9237,8 +9277,9 @@ procedure TPyVar.SetValueFromVariant( const value : Variant );
 
 procedure TPythonThread.Execute;
 var
- global_state : PPyThreadState;
- gilstate : PyGILState_STATE;
+ global_state: PPyThreadState;
+ gilstate: PyGILState_STATE;
+ Status: PyStatus;
 begin
  with GetPythonEngine do
  begin
@@ -9256,7 +9297,12 @@ procedure TPythonThread.Execute;
  gilstate := PyGILState_Ensure();
  global_state := PyThreadState_Get;
  PyThreadState_Swap(nil);
- fThreadState := Py_NewInterpreter;
+
+ if (fThreadExecMode = emNewInterpreter) or
+ ((FMajorVersion = 3) and (FMinorVersion < 12)) or
+ PyStatus_Exception(Py_NewInterpreterFromConfig(@fThreadState, @InterpreterConfig))
+ then
+ fThreadState := Py_NewInterpreter;
 
  if Assigned( fThreadState) then
  begin
@@ -9705,5 +9751,10 @@ function PythonVersionFromRegVersion(const ARegVersion: string;
  Result := (AMajorVersion > 0) and (AMinorVersion > 0);
 end;
 
+function PyStatus_Exception(const APyStatus: PyStatus): Boolean;
+begin
+ Result := APyStatus._type <> _PyStatus_TYPE_OK;
+end;
+
 end.