Ticket #67: _syckmodule.diff

File _syckmodule.diff, 7.7 KB (added by xi, 7 years ago)

a patch to remove GIL management

  • _syckmodule.c

    old new  
    10291029static SYMID 
    10301030PySyckParser_node_handler(SyckParser *parser, SyckNode *node) 
    10311031{ 
    1032     PyGILState_STATE gs; 
    1033  
    10341032    PySyckParserObject *self = (PySyckParserObject *)parser->bonus; 
    10351033 
    10361034    SYMID index; 
     
    10421040    if (self->halt) 
    10431041        return -1; 
    10441042 
    1045     gs = PyGILState_Ensure(); 
    1046  
    10471043    switch (node->kind) { 
    10481044 
    10491045        case syck_str_kind: 
     
    11041100    Py_DECREF(object); 
    11051101 
    11061102    index = PyList_GET_SIZE(self->symbols); 
    1107     PyGILState_Release(gs); 
    11081103    return index; 
    11091104 
    11101105error: 
    11111106    Py_XDECREF(object); 
    1112     PyGILState_Release(gs); 
    11131107    self->halt = 1; 
    11141108    return -1; 
    11151109} 
     
    11171111static void 
    11181112PySyckParser_error_handler(SyckParser *parser, char *str) 
    11191113{ 
    1120     PyGILState_STATE gs; 
    1121  
    11221114    PySyckParserObject *self = (PySyckParserObject *)parser->bonus; 
    11231115    PyObject *value; 
    11241116 
    11251117    if (self->halt) return; 
    11261118 
    1127     gs = PyGILState_Ensure(); 
    1128  
    11291119    self->halt = 1; 
    11301120 
    11311121    value = Py_BuildValue("(sii)", str, 
     
    11341124        PyErr_SetObject(PySyck_Error, value); 
    11351125    } 
    11361126 
    1137     PyGILState_Release(gs); 
    11381127} 
    11391128 
    11401129SyckNode * 
    11411130PySyckParser_bad_anchor_handler(SyckParser *parser, char *anchor) 
    11421131{ 
    1143     PyGILState_STATE gs; 
    1144  
    11451132    PySyckParserObject *self = (PySyckParserObject *)parser->bonus; 
    11461133 
    11471134    if (!self->halt) { 
    1148         gs = PyGILState_Ensure(); 
    1149  
    11501135        self->halt = 1; 
    11511136        PyErr_SetString(PyExc_TypeError, "recursive anchors are not implemented"); 
    1152  
    1153         PyGILState_Release(gs); 
    11541137    } 
    11551138 
    11561139    return syck_alloc_str(); 
     
    11591142static long 
    11601143PySyckParser_read_handler(char *buf, SyckIoFile *file, long max_size, long skip) 
    11611144{ 
    1162     PyGILState_STATE gs; 
    1163  
    11641145    PySyckParserObject *self = (PySyckParserObject *)file->ptr; 
    11651146 
    11661147    PyObject *value; 
     
    11761157     
    11771158    max_size -= skip; 
    11781159 
    1179     gs = PyGILState_Ensure(); 
    1180  
    11811160    value = PyObject_CallMethod(self->source, "read", "(i)", max_size); 
    11821161    if (!value) { 
    11831162        self->halt = 1; 
    11841163 
    1185         PyGILState_Release(gs); 
    1186  
    11871164        return skip; 
    11881165    } 
    11891166 
     
    11921169        PyErr_SetString(PyExc_TypeError, "file-like object should return a string"); 
    11931170        self->halt = 1; 
    11941171         
    1195         PyGILState_Release(gs); 
    1196  
    11971172        return skip; 
    11981173    } 
    11991174 
     
    12021177    if (!length) { 
    12031178        Py_DECREF(value); 
    12041179 
    1205         PyGILState_Release(gs); 
    1206  
    12071180        return skip; 
    12081181    } 
    12091182 
     
    12121185        PyErr_SetString(PyExc_ValueError, "read returns an overly long string"); 
    12131186        self->halt = 1; 
    12141187 
    1215         PyGILState_Release(gs); 
    1216  
    12171188        return skip; 
    12181189    } 
    12191190 
     
    12231194 
    12241195    Py_DECREF(value); 
    12251196 
    1226     PyGILState_Release(gs); 
    1227  
    12281197    return length; 
    12291198} 
    12301199 
     
    13051274    } 
    13061275 
    13071276    self->parsing = 1; 
    1308     Py_BEGIN_ALLOW_THREADS 
    13091277    index = syck_parse(self->parser)-1; 
    1310     Py_END_ALLOW_THREADS 
    13111278    self->parsing = 0; 
    13121279 
    13131280    if (self->halt || self->parser->eof) { 
     
    15891556static void 
    15901557PySyckEmitter_node_handler(SyckEmitter *emitter, st_data_t id) 
    15911558{ 
    1592     PyGILState_STATE gs; 
    1593  
    15941559    PySyckEmitterObject *self = (PySyckEmitterObject *)emitter->bonus; 
    15951560 
    15961561    PySyckNodeObject *node; 
     
    16041569 
    16051570    if (self->halt) return; 
    16061571 
    1607     gs = PyGILState_Ensure(); 
    1608  
    16091572    node = (PySyckNodeObject *)PyList_GetItem(self->symbols, id); 
    16101573    if (!node) { 
    16111574        PyErr_SetString(PyExc_RuntimeError, "unknown data id"); 
    16121575        self->halt = 1; 
    1613         PyGILState_Release(gs); 
    16141576        return; 
    16151577    } 
    16161578 
     
    16181580        tag = PyString_AsString(node->tag); 
    16191581        if (!tag) { 
    16201582            self->halt = 1; 
    1621             PyGILState_Release(gs); 
    16221583            return; 
    16231584        } 
    16241585    } 
     
    16301591        if (!PyList_Check(node->value)) { 
    16311592            PyErr_SetString(PyExc_TypeError, "value of _syck.Seq must be a list"); 
    16321593            self->halt = 1; 
    1633             PyGILState_Release(gs); 
    16341594            return; 
    16351595        } 
    16361596        l = PyList_GET_SIZE(node->value); 
     
    16391599            if ((index = PyDict_GetItem(self->nodes, item))) { 
    16401600                syck_emit_item(emitter, PyInt_AS_LONG(index)); 
    16411601                if (self->halt) { 
    1642                     PyGILState_Release(gs); 
    16431602                    return; 
    16441603                } 
    16451604            } 
    16461605            else { 
    16471606                PyErr_SetString(PyExc_RuntimeError, "sequence item is not marked"); 
    16481607                self->halt = 1; 
    1649                 PyGILState_Release(gs); 
    16501608                return; 
    16511609            } 
    16521610        } 
     
    16651623                    PyErr_SetString(PyExc_TypeError, 
    16661624                            "value of _syck.Map must be a list of pairs or a dictionary"); 
    16671625                    self->halt = 1; 
    1668                     PyGILState_Release(gs); 
    16691626                    return; 
    16701627                } 
    16711628                for (j = 0; j < 2; j++) { 
     
    16731630                    if ((index = PyDict_GetItem(self->nodes, item))) { 
    16741631                        syck_emit_item(emitter, PyInt_AS_LONG(index)); 
    16751632                        if (self->halt) { 
    1676                             PyGILState_Release(gs); 
    16771633                            return; 
    16781634                        } 
    16791635                    } 
    16801636                    else { 
    16811637                        PyErr_SetString(PyExc_RuntimeError, "mapping item is not marked"); 
    16821638                        self->halt = 1; 
    1683                         PyGILState_Release(gs); 
    16841639                        return; 
    16851640                    } 
    16861641                } 
     
    16941649                    if ((index = PyDict_GetItem(self->nodes, item))) { 
    16951650                        syck_emit_item(emitter, PyInt_AS_LONG(index)); 
    16961651                        if (self->halt) { 
    1697                             PyGILState_Release(gs); 
    16981652                            return; 
    16991653                        } 
    17001654                    } 
    17011655                    else { 
    17021656                        PyErr_SetString(PyExc_RuntimeError, "mapping item is not marked"); 
    17031657                        self->halt = 1; 
    1704                         PyGILState_Release(gs); 
    17051658                        return; 
    17061659                    } 
    17071660                } 
     
    17111664            PyErr_SetString(PyExc_TypeError, 
    17121665                    "value of _syck.Map must be a list of pairs or a dictionary"); 
    17131666            self->halt = 1; 
    1714             PyGILState_Release(gs); 
    17151667            return; 
    17161668        } 
    17171669 
     
    17211673    else if (PyObject_TypeCheck((PyObject *)node, &PySyckScalar_Type)) { 
    17221674        if (PyString_AsStringAndSize(node->value, &str, &len) < 0) { 
    17231675            self->halt = 1; 
    1724             PyGILState_Release(gs); 
    17251676            return; 
    17261677        } 
    17271678        syck_emit_scalar(emitter, tag, ((PySyckScalarObject *)node)->style, 
     
    17331684    else { 
    17341685        PyErr_SetString(PyExc_TypeError, "Node instance is required"); 
    17351686        self->halt = 1; 
    1736         PyGILState_Release(gs); 
    17371687        return; 
    17381688    }    
    1739     PyGILState_Release(gs); 
    17401689} 
    17411690 
    17421691static void 
    17431692PySyckEmitter_write_handler(SyckEmitter *emitter, char *buf, long len) 
    17441693{ 
    1745     PyGILState_STATE gs; 
    1746  
    17471694    PySyckEmitterObject *self = (PySyckEmitterObject *)emitter->bonus; 
    17481695 
    1749     gs = PyGILState_Ensure(); 
    1750  
    17511696    if (!PyObject_CallMethod(self->output, "write", "(s#)", buf, len)) 
    17521697        self->halt = 1; 
    1753  
    1754     PyGILState_Release(gs); 
    17551698} 
    17561699 
    17571700static int 
     
    20111954        return NULL; 
    20121955    } 
    20131956 
    2014     Py_BEGIN_ALLOW_THREADS 
    20151957    syck_emit(self->emitter, 0); 
    20161958    syck_emitter_flush(self->emitter, 0); 
    2017     Py_END_ALLOW_THREADS 
    20181959 
    20191960    syck_free_emitter(self->emitter); 
    20201961    self->emitter = NULL; 
     
    21382079{ 
    21392080    PyObject *m; 
    21402081 
    2141     PyEval_InitThreads();   /* Fix segfault for Python 2.3 */ 
    2142  
    21432082    if (PyType_Ready(&PySyckNode_Type) < 0) 
    21442083        return; 
    21452084    if (PyType_Ready(&PySyckScalar_Type) < 0)