PDL::Internalsp - Online sa Cloud

PROGRAMA:

NAME

PDL::Internals - paglalarawan ng ilang aspeto ng kasalukuyang internals

DESCRIPTION

Intro
Ipinapaliwanag ng dokumentong ito ang iba't ibang aspeto ng kasalukuyang pagpapatupad ng PDL. Kung ikaw lang
Gusto mong gumamit ng PDL para sa isang bagay, tiyak na hindi mo kailangang basahin ito. Kahit gusto mo
upang i-interface ang iyong mga C routine sa PDL o lumikha ng mga bagong PDL::PP function, hindi mo na kailangan
basahin ang man page na ito (bagaman maaaring ito ay nagbibigay-kaalaman). Ang dokumentong ito ay pangunahing inilaan para sa
mga taong interesado sa pag-debug o pagpapalit ng mga internal ng PDL. Upang basahin ito, isang magandang
pag-unawa sa wikang C at programming at mga istruktura ng data sa pangkalahatan ay
kinakailangan, pati na rin ang ilang pang-unawa sa Perl. Kung babasahin mo ang dokumentong ito at
nauunawaan ang lahat ng ito at nagagawang ituro kung ano ang tinutukoy ng alinmang bahagi ng dokumentong ito sa
PDL core source at dagdag na pakikibaka upang maunawaan ang PDL::PP, ikaw ay iginawad sa
pamagat na "PDL Guru" (siyempre, ang kasalukuyang bersyon ng dokumentong ito ay hindi kumpleto kaya
ito ay sunod sa imposible mula lamang sa mga talang ito).

Babala: Kung mukhang luma na ang dokumentong ito, mangyaring ipaalam sa PDL
listahan ng email ng mga porter ([protektado ng email]). Maaring mangyari ito.

Piddles
Ang pdl data object ay karaniwang isang opaque scalar reference sa isang pdl structure sa
alaala. Bilang kahalili, maaari itong hash reference na may field na "PDL" na naglalaman ng
scalar reference (ginagawa nitong madali ang pag-overload ng piddles, tingnan ang PDL::Objects). Madali mo
alamin sa antas ng Perl kung anong uri ng piddle ang iyong kinakaharap. Ang halimbawang code
sa ibaba ay nagpapakita kung paano ito gagawin:

# tingnan kung piddle ito
mamatay "hindi isang piddle" maliban kung UNIVERSAL::isa($pdl, 'PDL');
# ito ba ay isang scalar ref o isang hash ref?
if (UNIVERSAL::isa($pdl, "HASH")) {
mamatay na "hindi wastong PDL" maliban kung umiiral ang $pdl->{PDL} &&
UNIVERSAL::isa($pdl->{PDL},'PDL');
print "Ito ay isang hash reference,",
" ang field ng PDL ay naglalaman ng scalar ref\n";
} Iba pa {
print "Ito ay isang scalar ref na tumuturo sa address na $$pdl sa memorya\n";
}

Ang scalar reference ay tumuturo sa numeric address ng isang C structure ng uri na "pdl" which is
tinukoy sa pdl.h. Ang pagmamapa sa pagitan ng bagay sa antas ng Perl at ng istraktura ng C
na naglalaman ng aktwal na data at istruktura na bumubuo sa isang piddle ay ginagawa ng PDL
typemap. Ang mga function na ginamit sa PDL typemap ay halos tinukoy sa tuktok ng
file pdlcore.h. Kaya ano ang hitsura ng istraktura:

struct pdl {
unsigned long magicno; /* Palaging nag-iimbak ng PDL_MAGICNO bilang isang sanity check */
/* Ito ang una kaya karamihan sa mga pag-access ng pointer sa maling uri ay nahuli */
int estado; /* Anong meron sa pdl na ito */

pdl_trans *trans; /* Opaque pointer sa internals ng pagbabago mula sa
magulang */

pdl_vaffine *vafftrans;

walang bisa* sv; /* (opsyonal) pointer pabalik sa orihinal na sv.
LAGING suriin kung hindi null bago gamitin.
Hindi namin maaaring inc refcnt sa isang ito o gusto namin
hindi kailanman masisira */

walang bisa *datasv; /* Pointer sa SV na naglalaman ng data. Refcnt inced */
walang bisa *data; /* Null: walang data na inilaan para sa isang ito */
PDL_Indx nvals; /* Ilang value ang inilaan */
int datatype;
PDL_Indx *dims; /* Array ng mga sukat ng data */
PDL_Indx *dimincs; /* Array ng data default increments */
maikling ndims; /* Bilang ng mga sukat ng data */

unsigned char *threadids; /* Panimulang index ng thread index set n */
unsigned char nthreadids;

pdl *progenitor; /* Nasa isang mutated family ako. gumawa_pisikal_ngayon ay dapat
kopyahin mo ako sa bagong henerasyon. */
pdl *future_me; /* Ako ang "noon" pdl at ito ang aking "ngayon" (o mas moderno
bersyon, gayon pa man */

pdl_children mga bata;

maikling buhay_para; /* Ang panig ng Perl ay hindi natukoy; tanggalin mo ako kapag */

PDL_Indx def_dims[PDL_NDIMS]; /* Preallocated na espasyo para sa kahusayan */
PDL_Indx def_dimincs[PDL_NDIMS]; /* Preallocated na espasyo para sa kahusayan */
unsigned char def_threadids[PDL_NTHREADIDS];

struct pdl_magic *magic;

walang bisa * hdrsv; /* "header", settable mula sa labas */
};

Ito ay isang istraktura para sa pag-iimbak lamang ng ilang data sa - ano ang nangyayari?

Data imbakan
Magsisimula tayo sa ilan sa mga mas simpleng miyembro: una sa lahat, nariyan ang
miyembro

walang bisa *datasv;

na talagang isang pointer sa isang istraktura ng Perl SV ("SV *"). Ang SV ay inaasahang magiging
kumakatawan sa isang string, kung saan ang data ng piddle ay naka-imbak sa isang mahigpit na nakaimpake
anyo. Ang pointer na ito ay binibilang bilang isang sanggunian sa SV kaya ang bilang ng sanggunian ay naging
nadagdagan noong inilagay ang "SV *" dito (kailangang gawin ng negosyong ito sa bilang ng sanggunian
gamit ang mekanismo ng pangongolekta ng basura ni Perl -- huwag mag-alala kung hindi ito gaanong ibig sabihin
ikaw). Ang pointer na ito ay pinapayagan na magkaroon ng halaga na "NULL" na nangangahulugang walang
aktwal na Perl SV para sa data na ito - halimbawa, ang data ay maaaring ilaan ng isang "mmap"
operasyon. Tandaan na ang paggamit ng isang SV* ay para lamang sa kaginhawahan, nagbibigay-daan ito sa madali
pagbabago ng naka-pack na data mula sa mga file sa piddles. Ang iba pang mga pagpapatupad ay hindi
hindi kasama.

Ang aktwal na pointer sa data ay naka-imbak sa miyembro

walang bisa *data;

na naglalaman ng isang pointer sa isang lugar ng memorya na may espasyo para sa

PDL_Indx nvals;

data item ng uri ng data ng piddle na ito. Ang PDL_Indx ay maaaring 'mahaba' o 'mahaba'
depende sa kung ang iyong perl ay 64bit o hindi.

Ang uri ng data ng data ay naka-imbak sa variable

int datatype;

ang mga halaga para sa miyembrong ito ay ibinibigay sa enum na "pdl_datatypes" (tingnan pdl.h).
Sa kasalukuyan mayroon kaming byte, maikli, hindi naka-sign na maikli, mahaba, float at dobleng uri, tingnan din
PDL::Mga Uri.

Mga Dimensyon
Ang bilang ng mga sukat sa piddle ay ibinibigay ng miyembro

int ndims;

na nagpapakita kung gaano karaming mga entry ang mayroon sa mga array

PDL_Indx *dims;
PDL_Indx *dimincs;

Ang mga array na ito ay malapit na nauugnay: ang "dims" ay nagbibigay ng mga sukat ng mga sukat at
Ang "dimincs" ay palaging kinakalkula ng code

PDL_Indx inc = 1;
para sa(i=0; i ndims; i++) {
it->dimincs[i] = inc; inc *= it->dims[i];
}

sa nakagawiang "pdl_resize_defaultincs" sa "pdlapi.c". Ang ibig sabihin nito ay ang
dimincs ay maaaring gamitin upang kalkulahin ang offset sa pamamagitan ng code tulad ng

PDL_Indx off = 0;
para sa(i=0; i ndims; i++) {
offs += it->dimincs[i] * index[i];
}

ngunit ito ay hindi palaging ang tamang bagay na gawin, hindi bababa sa walang pagsuri para sa tiyak
bagay muna.

Default na imbakan
Dahil ang karamihan sa mga piddle ay walang higit sa 6 na dimensyon, ito ay higit pa
mahusay na magkaroon ng default na imbakan para sa mga sukat at diminc sa loob ng PDL
struct.

PDL_Indx def_dims[PDL_NDIMS];
PDL_Indx def_dimincs[PDL_NDIMS];

Ang "dims" at "dimincs" ay maaaring itakda upang tumuro sa simula ng mga array na ito kung
Ang "ndims" ay mas maliit sa o katumbas ng compile-time constant na "PDL_NDIMS". Ito ay
mahalagang tandaan kapag nagpapalaya ng piddle struct. Ang parehong naaangkop para sa mga threadid:

unsigned char def_threadids[PDL_NTHREADIDS];

Salamangka
Posibleng ilakip ang magic sa piddles, katulad ng sariling magic mechanism ni Perl. Kung
ang pointer ng miyembro

struct pdl_magic *magic;

ay nonzero, ang PDL ay may kalakip na mahika. Ang pagpapatupad ng magic ay maaaring
nakuha mula sa file pdlmagic.c sa pamamahagi.

estado
Ang isa sa mga unang miyembro ng istraktura ay

int estado;

Ang mga posibleng flag at ang mga kahulugan nito ay ibinibigay sa "pdl.h". Ang mga ito ay pangunahing ginagamit sa
ipatupad ang tamad na mekanismo ng pagsusuri at subaybayan ang mga piddles sa mga ito
operasyon.

Mga pagbabagong-anyo at mga virtual na pagbabago sa affine
Tulad ng dapat mo nang malaman, ang mga piddle ay kadalasang nagdadala ng impormasyon tungkol sa kung saan sila nanggagaling
mula sa. Halimbawa, ang code

$b = $a->slice("2:5");
$b .= 1;

babaguhin ang $a. Kaya ang $b at $a kilala na sila ay konektado sa pamamagitan ng a
"hiwa"-pagbabagong anyo. Ang impormasyong ito ay nakaimbak sa mga miyembro

pdl_trans *trans;
pdl_vaffine *vafftrans;

Parehong $a (ang magulang) at $b (ang bata) ay nag-iimbak ng impormasyong ito tungkol sa
pagbabago sa naaangkop na mga puwang ng istraktura ng "pdl".

Ang "pdl_trans" at "pdl_vaffine" ay mga istruktura na titingnan natin nang mas detalyado
sa ibaba.

Ang mga Perl SV
Kapag ang mga piddle ay tinutukoy sa pamamagitan ng Perl SV, nag-iimbak kami ng karagdagang reference dito
sa miyembro

walang bisa* sv;

para makapagbalik ng reference sa user kapag gusto niyang suriin ang
istraktura ng pagbabago sa gilid ng Perl.

Gayundin, nag-iimbak kami ng isang opaque

walang bisa * hdrsv;

na kung saan ay para lamang sa paggamit ng user upang ikonekta ang arbitrary na data sa sv na ito. Itong isa
ay karaniwang manipulahin sa pamamagitan ng sethdr at gethdr na mga tawag.

Matalino sanggunian at pagbabagong-anyo: pagpipiraso at sabihin
Ang mga matalinong sanggunian at karamihan sa iba pang pangunahing pag-andar na tumatakbo sa mga piddle ay ipinatupad
sa pamamagitan ng Mga Pagbabago (Aas na nabanggit sa itaas) na kinakatawan ng uri na "pdl_trans" sa
PDL.

Ang isang pagbabagong-anyo ay nag-uugnay sa input at output piddles at naglalaman ng lahat ng imprastraktura na iyon
tumutukoy kung paano

· Ang mga output piddle ay nakuha mula sa input piddles

· mga pagbabago sa matalinong naka-link na mga piddle ng output (hal anak ng isang hiniwa magulang piddle)
ay inilipad pabalik sa input piddle sa mga pagbabagong kung saan ito ay sinusuportahan (ang
kadalasang ginagamit na halimbawa ang pagiging "hiwa" dito).

· datatype at laki ng output piddles na kailangang gawin ay nakuha

Sa pangkalahatan, ang pagsasagawa ng isang PDL function sa isang pangkat ng mga piddle ay nagreresulta sa paglikha ng isang
pagbabagong-anyo ng hiniling na uri na nag-uugnay sa lahat ng input at output na argumento (hindi bababa sa
yung mga piddles). Sa mga function ng PDL na sumusuporta sa daloy ng data sa pagitan ng input at output
args (hal. "slice", "index") ang pagbabagong ito ay nagli-link magulang (input) at anak (output)
permanenteng piddles hanggang sa ang link ay tahasang nasira ng kahilingan ng user ("sever" at
ang antas ng Perl) o lahat ng mga magulang at mga anak ay nawasak. Sa mga kasong iyon ang
ang pagbabago ay tamad na sinusuri, hal. isinasagawa lamang kapag ang mga halaga ng piddle ay aktwal
na-access.

In hindi umaagos mga function, halimbawa karagdagan ("+") at panloob na mga produkto ("panloob"), ang
Ang pagbabagong-anyo ay naka-install tulad ng sa dumadaloy na mga function ngunit pagkatapos ay ang pagbabagong-anyo ay
agad na naisakatuparan at nawasak (sinira ang link sa pagitan ng input at output args)
bago bumalik ang function.

Dapat tandaan na ang malapit na link sa pagitan ng input at output args ng isang dumadaloy na function
(tulad ng slice) ay nangangailangan na ang mga piddle na bagay na naka-link sa paraang ito ay panatilihing buhay
lampas sa punto kung saan sila ay nawala sa saklaw mula sa punto ng view ng Perl:

$a = mga zero(20);
$b = $a->slice('2:4');
undef $a; # huling sanggunian sa $a ay nawasak na ngayon

Bagama't dapat na ngayong sirain ang $a ayon sa mga tuntunin ni Perl ang pinagbabatayan na "pdl"
ang istraktura ay dapat lang talagang palayain kapag ang $b ay lumampas din sa saklaw (dahil ito pa rin
panloob na mga sanggunian ang ilan sa data ni $a). Ipinapakita ng halimbawang ito na ang ganitong daloy ng data
paradigm sa pagitan ng mga bagay na PDL ay nangangailangan ng isang espesyal na algorithm ng pagkasira na tumatagal ng
mga link sa pagitan ng piddles sa account at couples ang habang-buhay ng mga bagay na iyon. Ang hindi-
ang trivial algorithm ay ipinatupad sa function na "pdl_destroy" sa pdlapi.c. Sa katunayan, karamihan
ng code sa pdlapi.c at pdlfamily.c ay nag-aalala sa pagtiyak na ang piddles ("pdl
*"s) ay ginawa, ina-update at pinalaya sa tamang oras depende sa mga pakikipag-ugnayan sa
iba pang piddles sa pamamagitan ng mga pagbabagong PDL (tandaan, "pdl_trans").

Pag-access mga bata at mga magulang of a piddle
Kapag ang mga piddle ay dynamic na naka-link sa pamamagitan ng mga pagbabagong tulad ng iminungkahing sa itaas input at
ang mga output piddle ay tinutukoy bilang mga magulang at mga anak, ayon sa pagkakabanggit.

Ang isang halimbawa ng pagproseso ng mga anak ng isang piddle ay ibinigay ng "baddata" na paraan ng
PDL::Bad (available lang kung nag-compile ka ng PDL na may opsyong "WITH_BADVAL" na nakatakda sa 1,
ngunit kapaki-pakinabang pa rin bilang isang halimbawa!).

Isaalang-alang ang sumusunod na sitwasyon:

pdl> $a = rvals(7,7,Centre=>[3,4]);
pdl> $b = $a->slice('2:4,3:5');
pdl> ? vars
Mga variable ng PDL sa pangunahing package::

Pangalan Uri ng Dimensyon ng Daloy ng Estado Mem
-------------------------------------------------- --------------
$a Doble D [7,7] P 0.38Kb
$b Doble D [3,3] VC 0.00Kb

Ngayon, kung bigla akong magpasya na ang $a ay dapat na i-flag bilang posibleng naglalaman ng masasamang halaga,
paggamit

pdl> $a->baddata(1)

pagkatapos ay gusto ko ang estado ng $b - ito ay anak - upang baguhin din (dahil ito ay alinman
magbahagi o magmana ng ilan sa data ni $a at gayundin masama), para makakuha ako ng 'B' sa estado
bukid

pdl> ? vars
Mga variable ng PDL sa pangunahing package::

Pangalan Uri ng Dimensyon ng Daloy ng Estado Mem
-------------------------------------------------- --------------
$a Doble D [7,7] PB 0.38Kb
$b Doble D [3,3] VCB 0.00Kb

Ang kaunting mahika na ito ay ginagawa ng function na "propogate_badflag", na nakalista sa ibaba:

/* newval = 1 ay nangangahulugang itakda ang bandila, 0 ay nangangahulugang i-clear ito */
/* salamat kay Christian Soeller para dito */

void propogate_badflag( pdl *it, int newval ) {
PDL_DECL_CHILDLOOP(ito)
PDL_START_CHILDLOOP(ito)
{
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(ito);
int i;
para sa(i = trans->vtable->nparents;
i <trans->vtable->npdls;
i++ ) {
pdl *bata = trans->pdls[i];

if ( newval ) child->state |= PDL_BADVAL;
ibang bata->estado &= ~PDL_BADVAL;

/* siguraduhin na kami ay nagpapalaganap sa mga apo, atbp */
propogate_badflag( bata, newval );

} /* para sa: i */
}
PDL_END_CHILDLOOP(ito)
} /* propogate_badflag */

Dahil sa piddle ("pdl *it"), ang nakagawiang mga loop sa bawat istraktura ng "pdl_trans", kung saan
Ang pag-access sa istrukturang ito ay ibinibigay ng macro na "PDL_CHILDLOOP_THISCHILD". Ang mga bata
ng piddle ay naka-imbak sa "pdls" array, pagkatapos ng mga magulang, samakatuwid ang loop mula sa "i =
...nparents" hanggang "i = ...nparents - 1". Kapag mayroon kaming pointer sa pag-piddle ng bata, kami
magagawa natin ang gusto natin dito; dito binago natin ang halaga ng variable na "estado", ngunit ang
ang mga detalye ay hindi mahalaga). Ano is mahalaga ay tinatawag nating "propogate_badflag" dito
mag-piddle, para masiguradong mag-iikot tayo sa mga anak nito. Tinitiyak ng recursion na ito na makukuha natin ang lahat ng
Offspring ng isang partikular na piddle.

Access sa mga magulang ay katulad, na ang "para sa" loop ay pinalitan ng:

para sa(i = 0;
i <trans->vtable->nparents;
i++ ) {
/* gumawa ng mga bagay kasama ang magulang #i: trans->pdls[i] */
}

Ano ang in a pagbabagong-anyo ("pdl_trans")
Ang lahat ng mga pagbabago ay ipinatupad bilang mga istruktura

struct XXX_trans {
int magicno; /* para makita ang memory overwrite */
maikling bandila; /* estado ng trans */
pdl_transvtable *vtable; /* ang lahat ng mahalagang vtable */
void (*freeproc)(struct pdl_trans *); /* Tumawag para palayain ang trans na ito
(kung sakaling kailanganin naming malloc ang ilang bagay sa trans na ito) */
pdl *pdls[NP]; /* Ang mga pdl na kasama sa pagbabago */
int __datatype; /* ang uri ng pagbabagong-anyo */
/* sa pangkalahatan mas maraming miyembro
/* depende sa aktwal na pagbabagong-anyo (hiwain, idagdag, atbp)
*/
};

Tinutukoy ng pagbabago ang lahat ng "pdl" na kasangkot sa trans

pdl *pdls[NP];

na may "NP" depende sa bilang ng piddle args ng partikular na trans. Itinatala nito ang a
ay

maikling bandila;

at ang datatype

int __datatype;

ng trans (kung saan dapat i-convert ang lahat ng piddles maliban kung tahasan ang mga ito na na-type, PDL
mga function na ginawa gamit ang PDL::PP siguraduhin na ang mga conversion na ito ay ginagawa kung kinakailangan).
Ang pinakamahalaga ay ang pointer sa vtable (virtual table) na naglalaman ng aktwal
pag-andar

pdl_transvtable *vtable;

Ang istraktura ng vtable naman ay kamukha ng (medyo pinasimple mula sa pdl.h para
kalinawan)

typedef struct pdl_transvtable {
pdl_transtype transtype;
int flag;
int nparents; /* bilang ng parent pdls (input) */
int npdls; /* bilang ng mga pdl ng bata (output) */
char *per_pdl_flags; /* optimization flags */
void (*redodims)(pdl_trans *tr); /* alamin ang dims ng mga bata */
void (*readdata)(pdl_trans *tr); /* daloy ng mga magulang sa mga anak */
void (*writebackdata)(pdl_trans *tr); /* dumaloy pabalik */
walang bisa (*freetrans)(pdl_trans *tr); /* Palayain ang parehong nilalaman at ito ng
ang trans member */
pdl_trans *(*kopya)(pdl_trans *tr); /* Buong kopya */
int structsize;
pangalan ng karakter; /* Para sa mga debugger, karamihan */
} pdl_transvtable;

Nakatuon kami sa mga function ng callback:

void (*redodims)(pdl_trans *tr);

Gagawin ng "redodims" ang mga sukat ng piddles na kailangang gawin at tawagin
mula sa loob ng function ng API na dapat tawagan upang matiyak na ang mga sukat ng a
naa-access ang piddle (pdlapi.c):

void pdl_make_physdims(pdl *it)

Ang "readdata" at "writebackdata" ay may pananagutan para sa mga aktwal na pag-compute ng bata
data mula sa mga magulang o data ng magulang mula sa mga anak, ayon sa pagkakabanggit (ang
aspeto ng daloy ng data). Tinitiyak ng PDL core na ang mga ito ay tinatawag kung kinakailangan kapag piddle
naa-access ang data (lazy-evaluation). Ang pangkalahatang function ng API upang matiyak na ang piddle ay
up-to-date ay

void pdl_make_physvaffine(pdl *it)

na dapat tawagan bago i-access ang data ng piddle mula sa XS/C (tingnan Core.xs para sa ilang
mga halimbawa).

Ang "freetrans" ay nagpapalaya ng dynamic na inilalaan na memorya na nauugnay sa trans kung kinakailangan at
Maaaring kopyahin ng "kopya" ang pagbabagong-anyo. Muli, ang mga function na binuo gamit ang PDL::PP ay tiyaking iyon
Ang pagkopya at pagpapalaya sa pamamagitan ng mga callback na ito ay nangyayari sa tamang oras. (Kung hindi nila magawa
na mayroon kaming memory leak -- nangyari na ito sa nakaraan;).

Ang pagbabagong-anyo at vtable code ay halos hindi nakasulat sa pamamagitan ng kamay ngunit sa halip ay nabuo ng
PDL::PP mula sa maigsi na paglalarawan.

Ang ilang uri ng mga pagbabagong-anyo ay maaaring i-optimize sa napakahusay na pag-alis ng pangangailangan para sa
tahasang "readdata" at "writebackdata" na pamamaraan. Ang mga pagbabagong iyon ay tinatawag
pdl_vaffine. Karamihan sa mga function sa pagmamanipula ng dimensyon (hal., "slice", "xchg") ay nabibilang dito
klase.

Ang pangunahing lansihin ay ang magulang at anak ng naturang pagbabago ay gumagana sa parehong
(nakabahaging) block ng data na pinipili lang nilang bigyang-kahulugan nang iba (sa pamamagitan ng paggamit ng iba
"dims", "dimincs" at "offs" sa parehong data, ihambing ang "pdl" structure sa itaas). Bawat isa
Ang operasyon sa isang piddle na nagbabahagi ng data sa isa pa sa ganitong paraan ay awtomatiko
lumipad mula sa bata patungo sa magulang at pabalik -- tutal pareho silang nagbabasa at nagsusulat
bloke ng memorya. Ito ay kasalukuyang hindi Perl thread safe -- walang malaking kawalan dahil ang buong PDL
ang core ay hindi reentrant (Perl threading "!=" PDL threading!).

Mga lagda: sinulid sa ibabaw elementarya pagpapatakbo
Karamihan sa functionality na iyon ng PDL threading (awtomatikong pag-ulit ng mga elementary operations
over multi-dim piddles) ay ipinatupad sa file pdlthread.c.

Ang PDL::PP ay nakabuo ng mga function (sa partikular ang "readdata" at "writebackdata"
callback) gamitin ang imprastraktura na ito upang matiyak na ang pangunahing operasyon ay ipinatupad
sa pamamagitan ng trans ay ginanap sa pagsang-ayon sa threading semantics ng PDL.

Pagtukoy bago PDL function -- Pangkola code henerasyon
Mangyaring tingnan ang PDL::PP at mga halimbawa sa pamamahagi ng PDL. Ang pagpapatupad at syntax ay
kasalukuyang malayo sa perpekto ngunit ito ay gumagawa ng isang mahusay na trabaho!

Ang Ubod istruktura
Tulad ng tinalakay sa PDL::API, ang PDL ay gumagamit ng isang pointer sa isang istraktura upang payagan ang mga PDL module na ma-access sa
mga pangunahing gawain nito. Ang kahulugan ng istrukturang ito (ang "Core" struct) ay nasa pdlcore.h
(ginawa ni pdlcore.h.PL in Basic/Core) at may hitsura

/* Structure para humawak ng mga pointer na pangunahing gawain ng PDL para magamit ng
* maraming mga module
*/
struct Core {
I32 Bersyon;
pdl* (*SvPDLV) ( SV* );
void (*SetSV_PDL) ( SV *sv, pdl *it );
#if tinukoy(PDL_clean_namespace) || tinukoy(PDL_OLD_API)
pdl* (*bago) ( ); /* gawin itong gumana sa gimp-perl */
#iba
pdl* (*pdlnew) ( ); /* pinalitan ng pangalan dahil sa C++ clash */
#endif
pdl* (*tmp) ( );
pdl* (*lumikha) (int type);
void (*sirain) (pdl *it);
...
}
typedef struct Core Core;

Ang unang field ng istraktura ("Bersyon") ay ginagamit upang matiyak ang pagkakapare-pareho sa pagitan ng mga module
sa oras ng pagtakbo; ang sumusunod na code ay inilalagay sa seksyong BOOT ng nabuong xs code:

kung (PDL->Bersyon != PDL_CORE_VERSION)
Perl_croak(aTHX_ "Kailangang i-recompile ang Foo laban sa bagong naka-install na PDL");

Kung magdagdag ka ng bagong field sa Ubod struct dapat mong:

· talakayin ito sa listahan ng email ng pdl porters ([protektado ng email]) [kasama ang
posibilidad na gawin ang iyong mga pagbabago sa isang hiwalay na sangay ng CVS tree kung ito ay a
pagbabago na magtatagal upang makumpleto]

· dagdagan ng 1 ang halaga ng variable na $pdl_core_version sa pdlcore.h.PL. Ito ay nagtatakda
ang halaga ng "PDL_CORE_VERSION" C macro na ginamit upang i-populate ang field ng Bersyon

· magdagdag ng dokumentasyon (hal. sa PDL::API) kung ito ay isang "kapaki-pakinabang" na function para sa panlabas na module
mga manunulat (pati na rin ang pagtiyak na ang code ay nakadokumento rin gaya ng iba pang PDL;)

Gamitin ang PDL::Internalsp online gamit ang mga serbisyo ng onworks.net