PDL::Internalsp - آنلاین در ابر

برنامه:

نام

PDL::Internals - شرح برخی از جنبه های داخلی فعلی

شرح

معرفی
این سند جنبه های مختلف اجرای فعلی PDL را توضیح می دهد. اگر شما فقط
می خواهید از PDL برای چیزی استفاده کنید، قطعاً نیازی به خواندن این ندارید. حتی اگر بخواهی
برای اتصال روتین های C خود به PDL یا ایجاد توابع جدید PDL::PP، نیازی به
این صفحه مرد را بخوانید (اگرچه ممکن است آموزنده باشد). این سند در درجه اول برای
افرادی که علاقه مند به اشکال زدایی یا تغییر قسمت های داخلی PDL هستند. برای خواندن این، خوب است
درک زبان C و برنامه نویسی و ساختارهای داده به طور کلی است
مورد نیاز است، و همچنین درک پرل. اگر این سند را بخوانید و
همه آن را درک کرده و می توانند به آنچه در هر قسمت از این سند اشاره می کند اشاره کنند
منابع اصلی PDL و همچنین برای درک PDL::PP تلاش می کنند، به شما اعطا می شود
عنوان "PDL Guru" (البته نسخه فعلی این سند به قدری ناقص است که
این فقط از این یادداشت ها تقریباً غیرممکن است).

هشدار: اگر به نظر می رسد که این سند قدیمی شده است، لطفاً به PDL اطلاع دهید
لیست ایمیل باربرها ([ایمیل محافظت شده]). این ممکن است به خوبی اتفاق بیفتد.

پیدل ها
شی داده pdl به طور کلی یک مرجع اسکالر مات به یک ساختار pdl در است
حافظه از طرف دیگر، ممکن است یک مرجع هش با فیلد "PDL" حاوی این باشد
مرجع اسکالر (این امر بارگذاری بیش از حد piddle ها را آسان می کند، به PDL::Objects مراجعه کنید). شما به راحتی می توانید
در سطح پرل دریابید که با کدام نوع پیدل سروکار دارید. کد نمونه
در زیر نحوه انجام آن را نشان می دهد:

# بررسی کنید که آیا این مشکل است
die "not a piddle" مگر اینکه UNIVERSAL::isa($pdl, 'PDL');
# آیا این یک مرجع اسکالر است یا یک مرجع هش؟
if (UNIVERSAL::isa($pdl، "HASH")) {
"PDL معتبر نیست" مگر اینکه $pdl->{PDL} && وجود داشته باشد
UNIVERSAL::isa($pdl->{PDL},'PDL');
چاپ "این یک مرجع هش است،"،
" فیلد PDL حاوی ref اسکالر\n" است.
} دیگری {
چاپ "این یک مرجع اسکالر است که به آدرس $$pdl در حافظه اشاره می کند\n";
}

مرجع اسکالر به آدرس عددی یک ساختار C از نوع "pdl" اشاره می کند که این است
تعریف شده در pdl.h. نگاشت بین شی در سطح پرل و ساختار C
حاوی داده های واقعی و ساختاری که یک piddle را می سازد توسط PDL انجام می شود
نقشه تایپ توابع استفاده شده در نقشه نوع PDL تقریباً در بالای آن تعریف شده اند
پرونده pdlcore.h. بنابراین ساختار چگونه به نظر می رسد:

struct pdl {
ماژینو طولانی بدون امضا; /* همیشه PDL_MAGICNO را به عنوان چک سلامت ذخیره می کند */
/* این برای اولین بار است که بیشتر دسترسی های اشاره گر به نوع اشتباه گرفته می شود */
int state; /* در این pdf چیست */

pdl_trans *trans; /* اشاره گر مات به درونی های تبدیل از
والدین */

pdl_vaffine *vafftrans;

void* sv; /* (اختیاری) نشانگر بازگشت به sv اصلی.
همیشه قبل از استفاده، غیر پوچ بودن را بررسی کنید.
ما نمی توانیم به این یکی توجه کنیم وگرنه می خواهیم
هرگز نابود نشو */

void *datasv; /* اشاره گر به SV حاوی داده. refcnt inced */
void *data; /* تهی: هیچ داده ای برای این یکی تخصیص داده نشده است */
nvals PDL_Indx; /* چند مقدار تخصیص داده شده */
نوع داده int;
PDL_Indx *dims; /* آرایه ای از ابعاد داده */
PDL_Indx *dimincs; /* آرایه از افزایش های پیش فرض داده ها */
ندیم های کوتاه; /* تعداد ابعاد داده */

کاراکتر بدون امضا *threadids; /* شاخص شروع مجموعه شاخص رشته n */
char nthreadids بدون امضا;

pdl *progenitor; /* من در یک خانواده جهش یافته هستم. make_physical_now باید
من را به نسل جدید کپی کنید */
pdl *future_me; /* من pdl "آنوقت" هستم و این "اکنون" (یا مدرن تر) من است
نسخه، به هر حال */

pdl_فرزندان;

زندگی کوتاه_برای; /* سمت پرل ارجاع نشده است. وقتی منو حذف کن */

PDL_Indx def_dims[PDL_NDIMS]; /* فضای از پیش تخصیص یافته برای بهره وری */
PDL_Indx def_dimincs[PDL_NDIMS]; /* فضای از پیش تخصیص یافته برای بهره وری */
char unsigned def_threadids[PDL_NTHREADIDS];

struct pdl_magic *magic;

void *hdrsv; /* "هدر"، قابل تنظیم از خارج */
};

این یک ساختار کاملاً برای ذخیره برخی داده ها در آن است - چه اتفاقی می افتد؟

ذخیره سازی داده ها
ما می خواهیم با برخی از اعضای ساده تر شروع کنیم: اول از همه، وجود دارد
عضو

void *datasv;

که در واقع یک اشاره گر به ساختار Perl SV ("SV *") است. انتظار می رود SV باشد
نشان دهنده یک رشته است که در آن داده های piddle در یک بسته بندی محکم ذخیره می شود
فرم. این اشاره گر به عنوان یک مرجع به SV حساب می شود، بنابراین تعداد مرجع بوده است
هنگامی که "SV *" در اینجا قرار گرفت افزایش می یابد (این تجارت تعداد مرجع باید انجام شود
با مکانیسم جمع‌آوری زباله پرل - نگران نباشید اگر این مهم نیست
شما). این اشاره گر مجاز است مقدار "NULL" داشته باشد که به این معنی است که هیچ وجود ندارد
Perl SV واقعی برای این داده - به عنوان مثال، داده ها ممکن است توسط "mmap" تخصیص داده شوند
عمل. توجه داشته باشید که استفاده از SV* صرفاً برای راحتی بود، آن را آسان می کند
تبدیل داده های بسته بندی شده از فایل ها به piddle. سایر پیاده سازی ها نیستند
حذف شده

اشاره گر واقعی به داده ها در عضو ذخیره می شود

void *data;

که حاوی یک اشاره گر به یک ناحیه حافظه با فاصله برای

nvals PDL_Indx;

اقلام داده از نوع داده این piddle. PDL_Indx یا "طولانی" یا "طولانی طولانی" است
بسته به اینکه پرل شما 64 بیتی باشد یا خیر.

نوع داده داده ها در متغیر ذخیره می شود

نوع داده int;

مقادیر این عضو در فهرست "pdl_datatypes" آورده شده است (نگاه کنید به pdl.h).
در حال حاضر انواع بایت، کوتاه، کوتاه، بدون علامت، بلند، شناور و دوتایی داریم، همچنین ببینید
PDL::انواع.

ابعاد
تعداد ابعاد در پیدل توسط عضو داده می شود

int ndims;

که نشان می دهد چند ورودی در آرایه ها وجود دارد

PDL_Indx *dims;
PDL_Indx *dimincs;

این آرایه ها ارتباط نزدیکی با هم دارند: "dims" اندازه ابعاد و
"dimincs" همیشه با کد محاسبه می شود

PDL_Indx inc = 1;
برای (i=0; i ndims; i++) {
it->dimincs[i] = inc; inc *= it->dims[i];
}

در روال "pdl_resize_defaultincs" در "pdlapi.c". این به این معنی است که
از dimincs می توان برای محاسبه افست توسط کد مانند استفاده کرد

PDL_Indx offs = 0;
برای (i=0; i ndims; i++) {
offs += it->dimincs[i] * index[i];
}

اما این همیشه کار درستی نیست، حداقل بدون بررسی قطعی
اول چیزها

ذخیره سازی پیش فرض
از آنجایی که اکثریت قریب به اتفاق پیدل ها بیش از 6 بعد ندارند، بیشتر است
برای داشتن فضای ذخیره سازی پیش فرض برای ابعاد و کمرنگ های داخل PDL کارآمد است
ساخت.

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

"dims" و "dimincs" ممکن است تنظیم شوند تا به ابتدای این آرایه ها اشاره کنند if
"ndims" کوچکتر یا مساوی با ثابت زمان کامپایل "PDL_NDIMS" است. این هست
مهم است که هنگام آزاد کردن یک ساختار پیدل به آن توجه کنید. همین امر در مورد threadid ها نیز صدق می کند:

char unsigned def_threadids[PDL_NTHREADIDS];

جادویی
این امکان وجود دارد که جادو را به پیدل ها متصل کنید، دقیقاً مانند مکانیسم جادویی خود پرل. اگر
نشانگر عضو

struct pdl_magic *magic;

غیر صفر است، PDL مقداری جادو به آن متصل است. اجرای جادو می تواند باشد
از پرونده به دست آمده است pdlmagic.c در توزیع

دولت
یکی از اولین اعضای ساختار است

int state;

پرچم های احتمالی و معانی آنها در "pdl.h" آورده شده است. اینها عمدتاً استفاده می شوند
مکانیسم ارزیابی تنبل را اجرا کنید و ردیابی نقاط ضعف را در آنها دنبال کنید
عملیات.

دگرگونی ها و تبدیل های وابسته مجازی
همانطور که قبلاً باید می دانید، piddle ها اغلب حاوی اطلاعاتی در مورد جایی هستند که می آیند
از جانب. مثلا کد

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

$a را تغییر خواهد داد. بنابراین $b و $a دانستن که آنها از طریق a متصل می شوند
"برش" - تبدیل. این اطلاعات در اعضا ذخیره می شود

pdl_trans *trans;
pdl_vaffine *vafftrans;

هر دو $a (the پدر یا مادر) و $b (فرزند) این اطلاعات را در مورد ذخیره می کنند
تبدیل در اسلات های مناسب ساختار "pdl".

"pdl_trans" و "pdl_vaffine" ساختارهایی هستند که با جزئیات بیشتر به آنها خواهیم پرداخت.
زیر کلیک کنید.

پرل SVs
هنگامی که piddle ها از طریق Perl SV ارجاع می شوند، ما یک مرجع اضافی به آن ذخیره می کنیم
در عضو

void* sv;

تا زمانی که کاربر می خواهد آن را بازرسی کند، بتوان یک مرجع را به او بازگرداند
ساختار تحول در سمت پرل.

همچنین، ما یک مات را ذخیره می کنیم

void *hdrsv;

که فقط برای استفاده توسط کاربر برای اتصال داده های دلخواه با این sv است. این یکی
به طور کلی از طریق تماس های sethdr و gethdr دستکاری می شود.

هوشمند منابع و تحولات: برش و رقصیدن
ارجاعات هوشمند و سایر توابع اساسی که بر روی piddle ها کار می کنند پیاده سازی می شوند
از طريق تحولات (همانطور که در بالا ذکر شد) که با نوع "pdl_trans" در نمایش داده می شوند
PDL.

یک تبدیل، پایه‌های ورودی و خروجی را به هم پیوند می‌دهد و شامل تمام زیرساخت‌هایی است که می‌تواند
چگونه تعریف می کند

· پیدل های خروجی از پیدل های ورودی به دست می آیند

· تغییرات در حفره های خروجی متصل هوشمند (مثلاً کودک از یک برش خورده پدر یا مادر پیل)
در تبدیل هایی که در آن پشتیبانی می شود به پیدل ورودی بازگردانده می شوند (the
مثالی که اغلب در اینجا استفاده می شود "برش" است).

· نوع داده و اندازه پیدل های خروجی که باید ایجاد شوند به دست می آیند

به طور کلی، اجرای یک تابع PDL روی گروهی از piddle ها منجر به ایجاد a می شود
تبدیل نوع درخواستی که همه آرگومان های ورودی و خروجی را به هم پیوند می دهد (حداقل
آنهایی که گودال هستند). در توابع PDL که از جریان داده بین ورودی و خروجی پشتیبانی می کند
args (به عنوان مثال "برش"، "شاخص") این تبدیل پیوند می دهد پدر یا مادر (ورودی) و کودک (خروجی)
تا زمانی که پیوند به صراحت توسط درخواست کاربر شکسته شود ("Sever" at
سطح پرل) یا همه والدین و فرزندان از بین رفته اند. در آن موارد
تبدیل به صورت تنبل ارزیابی می شود، به عنوان مثال فقط زمانی اجرا می شود که مقادیر piddle واقعاً وجود داشته باشند
دسترسی پیدا کرد.

In غیر روان توابع، به عنوان مثال جمع ("+") و محصولات داخلی ("داخلی")،
تبدیل دقیقاً مانند توابع جریان نصب می شود، اما پس از آن تبدیل است
بلافاصله اجرا و نابود می شود (شکستن پیوند بین ارگ های ورودی و خروجی)
قبل از بازگشت تابع

لازم به ذکر است که ارتباط نزدیک بین ارگ های ورودی و خروجی یک تابع جریان دارد
(مانند برش) مستلزم آن است که اشیاء piddle که به این طریق به هم مرتبط هستند زنده نگه داشته شوند
فراتر از نقطه ای که آنها از نظر پرل از محدوده خارج شده اند:

$a = صفر(20)؛
$b = $a->slice('2:4');
unef $a; # آخرین مرجع به $a اکنون از بین رفته است

اگرچه $a اکنون باید طبق قوانین پرل نابود شود، "pdl" زیربنایی
ساختار باید در واقع تنها زمانی آزاد شود که $b نیز از محدوده خارج شود (زیرا هنوز
ارجاع داخلی به برخی از داده های $a). این مثال نشان می دهد که چنین جریان داده ای
پارادایم بین اشیاء PDL نیاز به یک الگوریتم تخریب خاص دارد که از آن استفاده می کند
بین پیدل ها ارتباط برقرار می کند و طول عمر آن اشیاء را جفت می کند. غیر
الگوریتم بی اهمیت در تابع "pdl_destroy" در پیاده سازی شده است pdlapi.c. در واقع ، بیشتر
از کد در pdlapi.c و pdfamily.c نگران اطمینان از اینکه piddle ها ("pdl
*"s) بسته به تعامل با آنها در زمان های مناسب ایجاد، به روز و آزاد می شوند
پیدل های دیگر از طریق تبدیل های PDL (به یاد داشته باشید، "pdl_trans").

دسترسی به فرزندان و پدر و مادر of a چاک زدن
هنگامی که piddle ها به صورت پویا از طریق تبدیل ها به عنوان ورودی و پیشنهادی بالا به هم مرتبط می شوند
پیدل های خروجی به ترتیب والدین و فرزندان نامیده می شوند.

نمونه ای از پردازش فرزندان یک پیدل با روش "baddata" ارائه شده است
PDL::Bad (فقط در صورتی موجود است که PDL را با گزینه "WITH_BADVAL" روی 1 کامپایل کرده باشید،
اما همچنان به عنوان مثال مفید است!).

وضعیت زیر را در نظر بگیرید:

pdl> $a = rvals(7,7,Centre=>[3,4]);
pdl> $b = $a->slice('2:4,3:5');
pdl> ? vars
متغیرهای PDL در بسته اصلی::

نوع نام ابعاد وضعیت جریان مم
-------------------------------------------------- --------------
$a Double D [7,7] P 0.38Kb
$b Double D [3,3،0.00] VC XNUMXKb

حال، اگر ناگهان تصمیم بگیرم که $a باید به عنوان احتمالاً حاوی مقادیر بد پرچم گذاری شود،
با استفاده از

pdl> $a->بدداده(1)

سپس من وضعیت $b را می خواهم - این است کودک - نیز تغییر خواهد کرد (زیرا این نیز خواهد بود
برخی از داده های $a را به اشتراک بگذارید یا به ارث ببرید و همینطور باشد بد، به طوری که من یک 'B' در دولت
رشته:

pdl> ? vars
متغیرهای PDL در بسته اصلی::

نوع نام ابعاد وضعیت جریان مم
-------------------------------------------------- --------------
$a Double D [7,7] PB 0.38Kb
$b Double D [3,3،0.00] VCB XNUMXKb

این بیت جادویی توسط تابع "propogate_badflag" انجام می شود که در زیر لیست شده است:

/* newval = 1 به معنی علامت تنظیم، 0 به معنای پاک کردن آن است */
/* با تشکر از کریستین سولر برای این */

void propogate_badflag( pdl *it, int newval ) {
PDL_DECL_CHILDLOOP (آن)
PDL_START_CHILDLOOP (آن)
{
pdl_trans *trans = PDL_CHILDLOOP_THISCHILD(it);
بین من
for( i = trans->vtable->nparents;
i < trans->vtable->npdls;
i++ ) {
pdl *child = trans->pdls[i];

if ( newval ) child->state |= PDL_BADVAL;
else child->state &= ~PDL_BADVAL;

/* مطمئن شوید که به نوه ها و غیره تکثیر می کنیم */
propogate_badflag( child, newval );

} /* برای: i */
}
PDL_END_CHILDLOOP (آن)
} /* propogate_badflag */

با توجه به یک piddle ("pdl *it")، روال از طریق هر ساختار "pdl_trans" حلقه می شود، جایی که
دسترسی به این ساختار توسط ماکرو "PDL_CHILDLOOP_THISCHILD" ارائه می شود. در فرزندان
از piddle در آرایه "pdls" پس از ذخیره می شوند پدر و مادر، از این رو حلقه از "i =
...nparents" به "i = ...nparents - 1". هنگامی که ما نشانگر را به piddle فرزند داشتیم، ما
می توانیم آنچه را که می خواهیم با آن انجام دهیم؛ در اینجا مقدار متغیر "state" را تغییر می دهیم، اما
جزئیات بی اهمیت هستند). چی is مهم این است که ما در این مورد "propogate_badflag" را صدا کنیم
piddle، تا اطمینان حاصل شود که ما از طریق فرزندان آن حلقه می زنیم. این بازگشت تضمین می کند که ما به همه موارد دسترسی داریم
فرزند از یک پیدل خاص

دسترسی به پدر و مادر مشابه است، با حلقه "for" جایگزین شده با:

برای (i = 0;
i < trans->vtable->nparents;
i++ ) {
/* کارها را با والد #i انجام دهید: trans->pdls[i] */
}

چه خبر in a دگرگونی ("pdl_trans")
همه تبدیل ها به عنوان ساختار اجرا می شوند

ساختار XXX_trans {
int magicno; /* برای تشخیص بازنویسی حافظه */
پرچم های کوتاه؛ /* حالت ترانس */
pdl_transvtable *vtable; /* vtable بسیار مهم */
void (*freeproc)(struct pdl_trans *); /* برای آزاد کردن این ترنس تماس بگیرید
(در صورتی که مجبور شدیم چیزهایی را در این ترانس بخریم) */
pdl *pdls[NP]; /* pdls های دخیل در تحول */
int __datatype; /* نوع تبدیل */
/* به طور کلی اعضای بیشتر
/* بسته به تبدیل واقعی (برش، افزودن و غیره)
*/
};

تبدیل تمام "pdl" های درگیر در ترانس را شناسایی می کند

pdl *pdls[NP];

با "NP" بسته به تعداد پیدل آرگ های ترانس خاص. الف را ثبت می کند
بود

پرچم های کوتاه؛

و نوع داده

int __datatype;

از trans (که همه piddle ها باید به آن تبدیل شوند، مگر اینکه به طور صریح تایپ شده باشند، PDL
توابع ایجاد شده با PDL::PP مطمئن شوید که این تبدیل ها در صورت لزوم انجام می شود).
از همه مهمتر اشاره گر به vtable (جدول مجازی) است که حاوی واقعی است
قابلیت

pdl_transvtable *vtable;

ساختار vtable به نوبه خود چیزی شبیه به (کمی ساده شده از pdl.h برای
وضوح)

typedef struct pdl_transvtable {
pdl_transtype transtype;
پرچم های بین المللی;
int nparents; /* تعداد pdlهای والد (ورودی) */
int npdls; /* تعداد pdls فرزند (خروجی) */
char *per_pdl_flags; /* پرچم های بهینه سازی */
void (*redodims)(pdl_trans *tr); /* تاریکی کودکان را دریابید */
void (*readdata)(pdl_trans *tr); /* جریان والدین به فرزندان */
void (*writebackdata)(pdl_trans *tr); /* جریان به سمت عقب */
void (*freetrans)(pdl_trans *tr); /* هم محتویات و هم آن را آزاد کنید
عضو ترنس */
pdl_trans *(*copy)(pdl_trans *tr); /* کپی کامل */
int structsize;
نام شخصیت؛ /* برای دیباگرها، بیشتر */
} pdl_transvtable;

ما بر روی توابع پاسخ به تماس تمرکز می کنیم:

void (*redodims)(pdl_trans *tr);

"redodims" ابعاد پیدل هایی را که باید ایجاد شود و نامیده می شود را مشخص می کند
از درون تابع API که باید فراخوانی شود تا اطمینان حاصل شود که ابعاد a
پیدل در دسترس هستند (pdlapi.c):

void pdl_make_physdims(pdl *it)

"readdata" و "writebackdata" مسئول محاسبات واقعی کودک هستند
داده‌های والدین یا داده‌های والدین از فرزندان، به ترتیب (
جنبه جریان داده). هسته PDL اطمینان حاصل می کند که در صورت نیاز هنگام piddle، آنها فراخوانی می شوند
داده ها قابل دسترسی است (ارزیابی تنبلی). عملکرد کلی API برای اطمینان از اینکه یک piddle است
به روز است

void pdl_make_physvaffine(pdl *it)

که باید قبل از دسترسی به داده های piddle از XS/C فراخوانی شود (نگاه کنید به Core.xs برای بعضی ها
مثال ها).

"freetrans" حافظه تخصیص یافته پویا مرتبط با trans را در صورت نیاز آزاد می کند و
"کپی" می تواند تبدیل را کپی کند. باز هم، توابع ساخته شده با PDL::PP اطمینان حاصل کنید که
کپی و آزادسازی از طریق این تماس ها در زمان های مناسب اتفاق می افتد. (اگر موفق نشدند
که ما یک نشت حافظه داریم -- این در گذشته اتفاق افتاده است ;).

کد تبدیل و vtable به سختی با دست نوشته می شود، بلکه توسط آن تولید می شود
PDL::PP از توضیحات مختصر.

انواع خاصی از تبدیل‌ها را می‌توان به‌طور بسیار کارآمدی بهینه‌سازی کرد و نیاز به آن را برطرف کرد
روش های صریح "readdata" و "writebackdata". آن تحولات نامیده می شود
pdl_vaffine. اکثر توابع دستکاری ابعاد (به عنوان مثال، "slice"، "xchg") متعلق به این هستند
کلاس.

ترفند اساسی این است که والدین و فرزند چنین تحولی روی همان کار می کنند
بلوک (به اشتراک گذاشته شده) داده که آنها فقط برای تفسیر متفاوت (با استفاده از موارد مختلف) انتخاب می کنند
"dims"، "dimincs" و "off" روی همان داده‌ها، ساختار "pdl" را در بالا مقایسه کنید). هر یک
بنابراین عملیات بر روی یک piddle به اشتراک گذاری داده با دیگری به این روش به صورت خودکار انجام می شود
از کودکی به پدر و مادر و برگشت -- بالاخره آنها یکسان می خوانند و می نویسند
بلوک حافظه در حال حاضر این موضوع برای پرل امن نیست -- از کل PDL ضرر بزرگی ندارد
هسته مجددا وارد نشده است (Perl threading "!=" PDL Threading!).

امضاها: نخ روی ابتدایی عملیات
بیشتر آن عملکرد رشته PDL (تکرار خودکار عملیات ابتدایی
بیش از چند کم نور) در فایل پیاده سازی شده است pdlthread.c.

توابع تولید شده PDL::PP (به ویژه "readdata" و "writebackdata"
callbacks) از این زیرساخت استفاده کنید تا مطمئن شوید که عملیات اساسی اجرا شده است
توسط trans مطابق با معناشناسی رشته‌ای PDL انجام می‌شود.

تعریف کردن جدید PDL توابع -- چسب رمز نسل
لطفاً به PDL::PP و نمونه هایی در توزیع PDL مراجعه کنید. پیاده سازی و نحو هستند
در حال حاضر از کامل بودن فاصله دارد، اما کار خوبی انجام می دهد!

La هسته ساختار
همانطور که در PDL::API بحث شد، PDL از یک اشاره گر به یک ساختار استفاده می کند تا به ماژول های PDL اجازه دسترسی به
روال اصلی آن تعریف این ساختار (ساختار "هسته") در pdlcore.h
(خلق شده توسط pdlcore.h.PL in پایه/هسته ای) و چیزی شبیه به آن است

/* ساختاری برای نگه داشتن نشانگرهای اصلی PDL به طوری که توسط آنها استفاده شود
* بسیاری از ماژول ها
*/
ساختار هسته {
نسخه I32;
pdl* (*SvPDLV) ( SV* );
void (*SetSV_PDL) (SV *sv, pdl *it );
#if defined(PDL_clean_namespace) || تعریف شده (PDL_OLD_API)
pdl* (*جدید) ( ); /* با gimp-perl کار کند */
# دیگر
pdl* (*pdlnew) ( ); /* به دلیل برخورد C++ تغییر نام داد */
# اندیف
pdl* (*tmp) ( );
pdl* (*create) (نوع int);
void (* تخریب) (pdl *it);
...
}
typedef struct Core Core.

اولین فیلد ساختار ("نسخه") برای اطمینان از سازگاری بین ماژول ها استفاده می شود
در زمان اجرا؛ کد زیر در قسمت BOOT کد xs تولید شده قرار می گیرد:

اگر (PDL->نسخه != PDL_CORE_VERSION)
Perl_croak(aTHX_ "Foo باید در برابر PDL تازه نصب شده دوباره کامپایل شود");

اگر یک فیلد جدید به هسته ساختار شما باید:

در مورد آن در لیست ایمیل پورترهای pdl بحث کنید ([ایمیل محافظت شده]) [با
امکان ایجاد تغییرات خود در یک شاخه جداگانه از درخت CVS در صورتی که یک
تغییری که تکمیل آن به زمان نیاز دارد]

· 1 مقدار متغیر $pdl_core_version را افزایش دهید pdlcore.h.PL. این مجموعه
مقدار ماکرو C "PDL_CORE_VERSION" که برای پر کردن قسمت Version استفاده می شود

· اگر یک تابع "مفید" برای ماژول خارجی است، اسناد را اضافه کنید (به عنوان مثال به PDL::API)
نویسندگان (و همچنین اطمینان از مستند بودن کد به اندازه بقیه PDL ؛)

از PDL::Internalsp به صورت آنلاین با استفاده از خدمات onworks.net استفاده کنید