PDL::APIp - Online di Cloud

PROGRAM:

NAMA

PDL::API - membuat piddle dari kode Perl dan C/XS

DESKRIPSI

Buku masak sederhana cara membuat piddle secara manual. Ini mencakup Perl dan C/XS
tingkat. Selain itu, ini menjelaskan rutinitas inti PDL yang dapat diakses dari yang lain
modul. Rutinitas ini pada dasarnya mendefinisikan API PDL. Jika Anda perlu mengakses piddles dari
C/XS Anda mungkin perlu tahu tentang fungsi-fungsi ini.

RINGKASAN

menggunakan PDL;
sub mkmypiddle {
...
}

membuat a kencing manual dari Perl

Terkadang Anda ingin membuat piddle manual dari data biner. Anda dapat melakukannya di
tingkat Perl. Contoh dalam distribusi mencakup beberapa rutinitas IO. Kode
cuplikan di bawah ini menggambarkan langkah-langkah yang diperlukan.

menggunakan Ikan Mas;
sub mkmypiddle {
$kelas saya = shift;
$pdl saya = $class->new;
$pdl->set_datatype($PDL_B);
@dims saya = (1,3,4);
$ukuran saya = 1;
untuk (@dims) { $ukuran *= $_ }
$pdl->setdims([@dims]);
$dref saya = $pdl->get_dataref();

# membaca data langsung dari file
buka $file saya, '
$len saya = $size*PDL::Core::howbig($pdl->get_datatype);
croak "tidak dapat membaca data yang cukup" jika
baca( $file, $$dref, $len) != $len;
tutup $file;
$pdl->upd_data();

kembali $pdl;
}

membuat a kencing in C

Contoh berikut membuat piddle di level C. Kami menggunakan modul "Inline" yang
benar-benar cara untuk antarmuka Perl dan C hari ini. Perhatikan penggunaan "PDL_INCLUDE",
Fungsi "PDL_TYPEMAP", "PDL_AUTO_INCLUDE" dan "PDL_BOOT" yang diimpor dari
"PDL::Inti::Dev". Mereka digunakan bersama dengan panggilan Inline Config untuk memastikan bahwa
typemap PDL, PDL termasuk file dan rutinitas PDL Core ditemukan selama
kompilasi dan kemudian eksekusi runtime.

gunakan PDL::LiteF;
gunakan PDL::Core::Dev;

$a = myfloatseq(); # latih konstruktor piddle C kami

print $a->info,"\n";

# alasan panggilan konfigurasi ini dijelaskan di bawah
gunakan Inline C => Konfigurasi =>
INC => &PDL_INCLUDE, # pastikan kita menemukan pdlcore.h dll
TYPEMAPS => &PDL_TYPEMAP, # gunakan peta ketik PDL
AUTO_INCLUDE => &PDL_AUTO_INCLUDE, # deklarasi global dan termasuk
BOOT => &PDL_BOOT; # kode boot untuk memuat struct Inti

gunakan Sebaris C;
Sebaris->init; #berguna jika Anda ingin dapat 'melakukan'-memuat skrip ini

__DATA__

__C__

static pdl* new_pdl(int datatype, PDL_Indx redup[], int ndims)
{
pdl *p = PDL->pdlnew();
PDL->setdim (p, redup, ndim); /* setel redup */
p->tipe data = tipe data; /* dan tipe datanya */
PDL->allocdata (p); /* mengalokasikan potongan data */

kembali p;
}

pdl* myfloatseq()
{
PDL_Indx redup[] = {5,5,5};
pdl *p = new_pdl(PDL_F,redup,3);
PDL_Float *dataf = (PDL_Float *) p->data;
PDL_Indx saya; /* dimensi mungkin 64bit */

untuk (i=0;i<5*5*5;i++)
dataf[i] = i; /* data harus diinisialisasi! */
kembali p;
}

Pembungkus Tujuan sendiri data ke a kencing
Terkadang Anda mendapatkan sepotong data dari sumber lain, misalnya pemrosesan gambar
perpustakaan, dll. Yang ingin Anda lakukan dalam hal ini adalah membungkus data Anda menjadi struct piddle di
tingkat C. Contoh menggunakan pendekatan ini dapat ditemukan di modul IO (di mana FastRaw
dan FlexRaw menggunakannya untuk akses mmapped) dan modul Gimp Perl (yang menggunakannya untuk membungkus Gimp
wilayah piksel menjadi piddle). Skrip berikut menunjukkan contoh sederhana:

gunakan PDL::LiteF;
gunakan PDL::Core::Dev;
gunakan PDL::Grafik::PGPLOT;

$b = mkpiddle();

cetak $b->info,"\n";

gambar1 $b;

gunakan Inline C => Konfigurasi =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE,
BOOT => &PDL_BOOT;

gunakan Sebaris C;
Sebaris->init;

__DATA__

__C__

/* membungkus sepotong data yang disediakan pengguna ke dalam piddle
* Anda harus menentukan dimensi (redup, ndim) dan
* tipe data (konstanta untuk tipe data dideklarasikan
* di pdl.h; misalnya PDL_B untuk tipe byte, dll)
*
* ketika piddle 'npdl' yang dibuat dihancurkan di
* Sisi Perl fungsi dilewatkan sebagai 'delete_magic'
* parameter akan dipanggil dengan penunjuk ke struktur pdl
* dan argumen 'delparam'.
* Ini memberi Anda kesempatan untuk melakukan pembersihan apa pun
* itu perlu. Misalnya, Anda mungkin harus
* secara eksplisit memanggil fungsi untuk membebaskan sumber daya
* terkait dengan penunjuk data Anda.
* Setidaknya 'delete_magic' harus nol penunjuk data piddle:
*
* batal hapus_mydata(pdl* pdl, int param)
* {
* pdl->data = 0;
*}
* pdl *p = pdl_wrap(dataku, PDL_B, redupkan, ndim, hapus_dataku,0);
*
* pdl_wrap mengembalikan pointer ke pdl
* yang telah dibuat.
*/
typedef batal (*DelMagic)(pdl *, int param);
static void default_magic(pdl *p, int pa) { p->data = 0; }
static pdl* pdl_wrap(void *data, int tipe data, PDL_Indx redup[],
int ndim, DelMagic delete_magic, int delparam)
{
pdl* npdl = PDL->pdlnew(); /* ambil wadah kosong */

PDL->setdims(npdl,redup,ndims); /* setel redup */
npdl->tipe data = tipe data; /* dan tipe datanya */
npdl->data = data; /* arahkan ke data Anda */
/* pastikan inti tidak mengganggu data Anda */
npdl->status |= PDL_DONTTOUCHDATA | PDL_ALOKASI;
jika (hapus_magic != NULL)
PDL->add_deletedata_magic(npdl, delete_magic, delparam);
lain
PDL->tambahkan_deletedata_magic(npdl, default_magic, 0);
kembali npdl;
}

#tentukan SZ 256
/* fungsi yang sangat konyol yang membuat gambar ramp
* pada kenyataannya ini bisa menjadi fungsi buram
* di beberapa perpustakaan yang Anda gunakan
*/
statis PDL_Byte* mkramp(batal)
{
PDL_Byte *data;
di aku; /* harus menggunakan PDL_Indx untuk mendukung pengindeksan pdl 64bit */

jika ((data = malloc(SZ*SZ*sizeof(PDL_Byte))) == NULL)
croak("mkram: Tidak dapat mengalokasikan memori");
untuk (i=0;i
data[i] = saya % SZ;

mengembalikan data;
}

/* fungsi ini menangani pembersihan yang diperlukan */
kekosongan statis delete_myramp(pdl* p, int param)
{
jika (p->data)
gratis(p->data);
p->data = 0;
}

pdl* mkpiddle()
{
PDL_Indx redup[] = {SZ,SZ};
pdl *p;

p = pdl_wrap((kosong *) mkramp(), PDL_B, redup, 2,
delete_myramp,0); /* delparam secara sewenang-wenang disetel ke 0 */
kembali p;
}

pegunungan details

Core struktur -- mendapatkan at PDL inti rutinitas at runtime
PDL menggunakan teknik yang mirip dengan yang digunakan oleh modul Tk untuk membiarkan modul lain menggunakan
rutinitas intinya. Pointer ke semua rutinitas PDL inti bersama disimpan di $PDL::SHARE
variabel. Kode XS harus mendapatkan pointer ini pada saat boot sehingga sisa
Kode C/XS kemudian dapat menggunakan penunjuk itu untuk akses saat dijalankan. Pemuatan awal ini
pointer paling mudah dicapai dengan menggunakan fungsi "PDL_AUTO_INCLUDE" dan "PDL_BOOT" yang
didefinisikan dan diekspor oleh "PDL::Core::Dev". Penggunaan umum dengan modul Inline memiliki
sudah didemonstrasikan:

gunakan Inline C => Konfigurasi =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE, # deklarasi
BOOT => &PDL_BOOT; # kode untuk bagian boot XS

Kode yang dikembalikan oleh "PDL_AUTO_INCLUDE" memastikan bahwa pdlcore.h disertakan dan dideklarasikan
variabel statis untuk menahan pointer ke struct "Core". Itu terlihat seperti
ini:

cetak PDL_AUTO_INCLUDE;

#termasuk
Inti statis* PDL; /* Struktur memegang fungsi inti C */
SV* CoreSV statis; /* Mendapat pointer ke Perl var memegang struktur inti */

Kode yang dikembalikan oleh "PDL_BOOT" mengambil variabel $PDL::SHARE dan menginisialisasi
pointer ke struct "Inti". Bagi mereka yang tahu jalan di sekitar Perl API di sini adalah
kode:

cetak PDL_BOOT;

perl_require_pv("PDL::Core"); /* pastikan PDL::Core dimuat */
CoreSV = perl_get_sv("PDL::SHARE",FALSE); /* Nilai SV* */
#jikandef aTHX_
#tentukan aTHX_
#berakhir jika
jika (CoreSV==NULL)
Perl_croak(aTHX_ "Kami membutuhkan modul PDL::Core, yang tidak ditemukan");
PDL = INT2PTR(Core*,SvIV( CoreSV )); /* Nilai inti */
jika (PDL->Versi != PDL_CORE_VERSION)
Perl_croak(aTHX_ "Kode perlu dikompilasi ulang terhadap PDL yang baru diinstal");

Struktur "Inti" berisi info versi untuk memastikan bahwa struktur didefinisikan dalam pdlcore.h
benar-benar sesuai dengan yang diperoleh saat runtime. Kode di atas menguji ini

jika (PDL->Versi != PDL_CORE_VERSION)
....

Untuk informasi lebih lanjut tentang struct Inti, lihat PDL::Internals.

Dengan persiapan ini, kode Anda sekarang dapat mengakses rutinitas inti seperti yang telah ditunjukkan di
beberapa contoh di atas, mis

pdl *p = PDL->pdlnew();

Secara default, variabel C bernama "PDL" digunakan untuk menahan pointer ke struct "Core". Jika
itu (untuk alasan apa pun) masalah Anda dapat secara eksplisit menentukan nama untuk
variabel dengan rutinitas "PDL_AUTO_INCLUDE" dan "PDL_BOOT":

gunakan Inline C => Konfigurasi =>
INC => &PDL_INCLUDE,
TYPEMAPS => &PDL_TYPEMAP,
AUTO_INCLUDE => &PDL_AUTO_INCLUDE 'PDL_Corep',
BOOT => &PDL_BOOT 'PDL_Corep';

Pastikan Anda menggunakan pengenal yang sama dengan "PDL_AUTO_INCLUDE" dan "PDL_BOOT" dan gunakan itu
pengenal yang sama dalam kode Anda sendiri. Misalnya, melanjutkan dari contoh di atas:

pdl *p = PDL_Corep->pdlnew();

Beberapa terpilih inti rutinitas menjelaskan
Definisi lengkap dari struct "Inti" dapat ditemukan di file pdlcore.h. di
berikut fungsi anggota yang paling sering digunakan dari struct ini dijelaskan secara singkat.

· "pdl *SvPDLV(SV *sv)"

· "pdl *SetSV_PDL(SV *sv, pdl *it)"

· "pdl *pdlbaru()"

"pdlnew" mengembalikan objek pdl kosong yang membutuhkan inisialisasi lebih lanjut untuk mengubahnya
ke dalam genangan air yang tepat. Contoh:

pdl *p = PDL->pdlnew();
PDL->setdim(p,redup,ndim);
p->tipe data = PDL_B;

· "pdl *null()"

· "SV *salin(pdl* p, char* )"

· "void *smallloc(STRLEN nbytes)"

· "int seberapa besar(int pdl_datatype)"

· "void add_deletedata_magic(pdl *p, void (*func)(pdl*, int), int param)"

· "kosongkan alokasi data(pdl *p)"

· "kosongkan make_physical(pdl *p)"

· "kosongkan make_physdims(pdl *p)"

· "kosongkan make_physvaffine(pdl *p)"

· "void qsort_X(PDL_Xtype *data, PDL_Indx a, PDL_Indx b)" dan "void
qsort_ind_X(PDL_Xtype *data, PDL_Indx *ix, PDL_Indx a, PDL_Indx b)"

dimana X adalah salah satu dari B,S,U,L,F,D dan Xtype adalah salah satu dari Byte, Short, Ushort, Long, Float atau
Dobel. PDL_Indx adalah tipe integer C yang sesuai dengan ukuran pengindeksan yang sesuai
untuk konfigurasi perl (ivsize dan ivtype). Itu bisa 'panjang' atau 'panjang
long' tergantung pada apakah Perl Anda diaktifkan 32bit atau 64bit.

· "float NaN_float" dan "double NaN_double"

Ini adalah konstanta untuk menghasilkan nilai NaN yang diperlukan.

· "void pdl_barf(const char* pat,...)" dan "void pdl_warn(const char* pat,...)"

Ini adalah padanan kode-C dari "muntah" dan "peringatkan". Mereka termasuk penanganan khusus
pesan kesalahan atau peringatan selama pthreading (yaitu prosesor multi-threading) yang
menunda pesan sampai setelah pthreading selesai. Ketika pthreading selesai,
"muntah" atau "peringatan" Perl disebut dengan pesan yang ditangguhkan. Ini diperlukan untuk menjaga
dari memanggil "barf" atau "warn" Perl selama pthreading, yang dapat menyebabkan segfaults.

Perhatikan bahwa "barf" dan "warn" telah didefinisikan ulang (menggunakan makro c-preprocessor) di
pdlcore.h ke "PDL->barf" dan "PDL->warn". Ini untuk menjaga kode XS atau PP dari
memanggil "muntah" atau "peringatan" Perl secara langsung, yang dapat menyebabkan kesalahan seg selama
pthreading.

Lihat PDL::ParallelCPU untuk informasi lebih lanjut tentang pthreading.

Gunakan PDL::APIp online menggunakan layanan onworks.net