PDL::Dataflowp - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

PDL::Dataflow -- ລາຍລະອຽດຂອງປັດຊະຍາຂອງ dataflow

ສະຫຼຸບສັງລວມ

pdl> $a = ສູນ(10)
pdl> $b = $a->slice("2:4:2");
pdl> $b ++;
pdl> ພິມ $a;
[ 0 0 1 0 1 0 0 0 0 0 ]

ຄໍາເຕືອນ

Dataflow ແມ່ນການທົດລອງຫຼາຍ. ຄຸນນະສົມບັດຈໍານວນຫຼາຍຂອງມັນແມ່ນພິການສໍາລັບ 2.0, ໂດຍສະເພາະ
ຄອບຄົວສໍາລັບການໄຫລຂອງຂໍ້ມູນຫນຶ່ງທິດທາງ. ຖ້າທ່ານຕ້ອງການໃຊ້ dataflow ທິດທາງດຽວສໍາລັບ
ບາງສິ່ງບາງຢ່າງ, ກະລຸນາຕິດຕໍ່ຜູ້ຂຽນກ່ອນແລະພວກເຮົາຈະຊອກຫາວິທີເຮັດໃຫ້ມັນເປັນປະໂຫຍດ
ອີກເທື່ອຫນຶ່ງ.

ກະແສຂໍ້ມູນສອງທິດທາງ (ເຊິ່ງປະຕິບັດ ->ປ່ຽງ() ແລະອື່ນໆ) ແມ່ນເຮັດວຽກຢ່າງເຕັມທີ່, ຢ່າງໃດກໍຕາມ.
ພຽງແຕ່ກ່ຽວກັບຟັງຊັນໃດນຶ່ງທີ່ສົ່ງຄືນບາງສ່ວນຍ່ອຍຂອງຄ່າໃນບາງ piddle ຈະເຮັດໃຫ້ a
ຜູກມັດນັ້ນ

$a = ບາງ piddle
$b = $a->slice("ບາງສ່ວນ");
$b->set(3,3,10);

ຍັງມີການປ່ຽນແປງອົງປະກອບທີ່ສອດຄ້ອງກັນໃນ $a. $b ໄດ້ກາຍເປັນປ່ອງຢ້ຽມຢ່າງມີປະສິດທິພາບສໍາລັບບາງຄົນ
ອົງປະກອບຍ່ອຍຂອງ $a. ນອກນັ້ນທ່ານຍັງສາມາດກໍານົດການປົກກະຕິຂອງທ່ານເອງທີ່ເຮັດປະເພດທີ່ແຕກຕ່າງກັນຂອງ
ຊຸດຍ່ອຍ. ຖ້າເຈົ້າບໍ່ຕ້ອງການ $b ເປັນ window ກັບ $a, ເຈົ້າຕ້ອງເຮັດ

$b = $a->slice("ບາງສ່ວນ")->ສຳເນົາ;

ການອັດສຳເນົາຈະປິດກະແສຂໍ້ມູນທັງໝົດລະຫວ່າງສອງປ່ຽງ.

ຄວາມ​ຫຍຸ້ງ​ຍາກ​ກັບ​ການ​ໄຫຼ​ຂອງ​ຂໍ້​ມູນ​ທິດ​ທາງ​ດຽວ​ແມ່ນ​ກ່ຽວ​ຂ້ອງ​ກັບ​ລໍາ​ດັບ​ເຊັ່ນ​:​

$b = $a + 1;
$b ++;

ບ່ອນທີ່ມີຜົນໄດ້ຮັບທີ່ເປັນໄປໄດ້ຫຼາຍຢ່າງແລະ semantics ໄດ້ຮັບຄວາມຂີ້ຕົວະເລັກນ້ອຍ.

ລາຍລະອຽດ

Dataflow ແມ່ນໃໝ່ຕໍ່ກັບ PDL2.0. ປັດຊະຍາພື້ນຖານທີ່ຢູ່ເບື້ອງຫລັງ dataflow ແມ່ນວ່າ

> $a = pdl 2,3,4;
> $b = $a * 2;
> ພິມ $b
[2 3 4]
> $a->set(0,5);
> ພິມ $b;
[10 3 4]

ຄວນເຮັດວຽກ. ມັນບໍ່ໄດ້. ມັນໄດ້ຖືກພິຈາລະນາວ່າການເຮັດນີ້ອາດຈະສັບສົນເກີນໄປ
ຈົວແລະຜູ້ໃຊ້ພາສາບາງຄັ້ງຄາວ. ດັ່ງນັ້ນ, ທ່ານຈໍາເປັນຕ້ອງໄດ້ເປີດຢ່າງຈະແຈ້ງ
dataflow, ດັ່ງນັ້ນ

> $a = pdl 2,3,4;
> $a->doflow();
> $b = $a * 2;
...

ຜະລິດຜົນໄດ້ຮັບທີ່ບໍ່ຄາດຄິດ. ສ່ວນທີ່ເຫຼືອຂອງເອກະສານນີ້ອະທິບາຍລັກສະນະຕ່າງໆແລະ
ລາຍລະອຽດຂອງການຈັດຕັ້ງປະຕິບັດ dataflow.

Lazy ການປະເມີນຜົນ

ໃນເວລາທີ່ທ່ານຄິດໄລ່ບາງສິ່ງບາງຢ່າງເຊັ່ນ: ຂ້າງເທິງ

> $a = pdl 2,3,4;
> $a->doflow();
> $b = $a * 2;

ບໍ່ມີຫຍັງຈະຖືກຄິດໄລ່ໃນຈຸດນີ້. ເຖິງແມ່ນວ່າຄວາມຊົງຈໍາສໍາລັບເນື້ອໃນຂອງ $b
ຍັງບໍ່ໄດ້ຈັດສັນ. ພຽງແຕ່ຄໍາສັ່ງ

> ພິມ $b

ຕົວຈິງແລ້ວຈະເຮັດໃຫ້ການຄິດໄລ່ $b. ນີ້ແມ່ນສິ່ງສໍາຄັນທີ່ຕ້ອງຈື່ໄວ້ໃນເວລາທີ່ເຮັດ
ການວັດແທກປະສິດທິພາບແລະມາດຕະຖານເຊັ່ນດຽວກັນກັບໃນເວລາທີ່ຕິດຕາມຄວາມຜິດພາດ.

ມີຄໍາອະທິບາຍສໍາລັບພຶດຕິກໍານີ້: ມັນອາດຈະຊ່ວຍປະຢັດຮອບວຽນແຕ່ສໍາຄັນກວ່ານັ້ນ,
ຈິນຕະນາການຕໍ່ໄປນີ້:

> $a = pdl 2,3,4;
> $b = pdl 5,6,7;
> $c = $a + $b;
...
> $a->ປັບຂະຫນາດ(4)
> $b->ປັບຂະຫນາດ(4)
> ພິມ $c;

ດຽວນີ້, ຖ້າ $c ຖືກປະເມີນລະຫວ່າງສອງການປັບຂະຫນາດ, ສະພາບຄວາມຜິດພາດຂອງຄວາມບໍ່ເຂົ້າກັນ
ຂະຫນາດຈະເກີດຂຶ້ນ.

ສິ່ງທີ່ເກີດຂື້ນໃນສະບັບປະຈຸບັນແມ່ນວ່າການປັບຂະຫນາດ $a ຍົກທຸງໃນ $c:
"PDL_PARENTDIMSCHANGED" ແລະ $b ພຽງແຕ່ຍົກທຸງດຽວກັນອີກເທື່ອຫນຶ່ງ. ເມື່ອ $c ຖືກປະເມີນຄັ້ງຕໍ່ໄປ,
ທຸງຖືກກວດສອບແລະພົບວ່າມີການຄິດໄລ່ຄືນໃຫມ່ແມ່ນຈໍາເປັນ.

ແນ່ນອນ, ບາງຄັ້ງການປະເມີນຄວາມຂີ້ຄ້ານສາມາດເຮັດໃຫ້ການແກ້ບັນຫາເຈັບປວດຫຼາຍຂຶ້ນ ເພາະວ່າອາດມີຄວາມຜິດພາດ
ເກີດຂຶ້ນບາງບ່ອນທີ່ເຈົ້າບໍ່ຄາດຄິດ. ການຕິດຕາມ stack ທີ່ດີກວ່າສໍາລັບຄວາມຜິດພາດແມ່ນຢູ່ໃນ
ເຮັດວຽກສໍາລັບ PDL, ອາດຈະເປັນເພື່ອໃຫ້ທ່ານສາມາດສະຫຼັບສະຫຼັບ $PDL::traceevals ແລະໄດ້ຮັບທີ່ດີ.
ຮ່ອງຮອຍຂອງຄວາມຜິດພາດທີ່ແທ້ຈິງແມ່ນ.

ຄອບຄົວ

ນີ້ແມ່ນ ໜຶ່ງ ໃນແນວຄວາມຄິດທີ່ສັບສົນຫຼາຍຂອງການໄຫຼເຂົ້າຂໍ້ມູນ ໜຶ່ງ ທິດທາງ. ພິຈາລະນາ
ລະຫັດຕໍ່ໄປນີ້ ($a ແລະ $b ແມ່ນ pdls ທີ່ມີການເປີດໃຊ້ dataflow):

$ c = $ a + $ b;
$e = $c + 1;
$d = $c->ເສັ້ນຂວາງ();
$d ++;
$f = $c + 1;

$e ແລະ $f ຄວນມີຫຍັງແດ່ຕອນນີ້? ຈະເປັນແນວໃດກ່ຽວກັບເວລາທີ່ $a ຖືກປ່ຽນແປງແລະການຄິດໄລ່ຄືນໃຫມ່ແມ່ນ
ເກີດຂຶ້ນ.

ເພື່ອເຮັດໃຫ້ dataflow ເຮັດວຽກຕາມທີ່ເຈົ້າຄາດຫວັງ, ແນວຄວາມຄິດທີ່ແປກປະຫລາດຈະຕ້ອງເປັນ
ແນະນໍາ: ຄອບຄົວ. ໃຫ້ພວກເຮົາສ້າງແຜນວາດ:

ab
\ /
c
/|
/ |
ed

ນີ້ແມ່ນສິ່ງທີ່ PDL ຕົວຈິງຢູ່ໃນຄວາມຊົງຈໍາຫຼັງຈາກສາມສາຍທໍາອິດ. ເມື່ອ $d ຖືກປ່ຽນ,
ພວກເຮົາຕ້ອງການໃຫ້ $c ປ່ຽນແປງ ແຕ່ພວກເຮົາບໍ່ຕ້ອງການ $e ປ່ຽນ ເພາະວ່າມັນຢູ່ໃນກຣາບແລ້ວ. ມັນ
ອາດຈະບໍ່ຈະແຈ້ງໃນປັດຈຸບັນວ່າເປັນຫຍັງທ່ານບໍ່ຢາກໃຫ້ມັນມີການປ່ຽນແປງແຕ່ຖ້າຫາກວ່າມີ 40 ແຖວຂອງລະຫັດ
ລະຫວ່າງແຖວທີ 2 ແລະທີ 4, ເຈົ້າຈະ. ດັ່ງນັ້ນພວກເຮົາຈໍາເປັນຕ້ອງເຮັດສໍາເນົາຂອງ $c ແລະ $d:

ab
\ /
ຄ' . . . ຄ
/| |
/ | |
ed' . . . df

ສັງເກດເຫັນວ່າພວກເຮົາ primed ຕົ້ນສະບັບ c ແລະ d, ເພາະວ່າພວກເຂົາບໍ່ກົງກັນກັບວັດຖຸ
ໃນ $c ແລະ $d ເພີ່ມເຕີມ. ນອກຈາກນັ້ນ, ສັງເກດເຫັນເສັ້ນຈຸດລະຫວ່າງສອງວັດຖຸ: ເມື່ອ $a ແມ່ນ
ມີການປ່ຽນແປງແລະແຜນວາດນີ້ຖືກປະເມີນຄືນໃຫມ່, $c ກໍ່ໄດ້ຮັບຄ່າຂອງ c' ກັບ the
ເພີ່ມເສັ້ນຂວາງ.

ເພື່ອສະຫຼຸບໂດຍທົ່ວໄປຂ້າງເທິງ, ທຸກຄັ້ງທີ່ piddle ມີການປ່ຽນແປງເຊັ່ນ: ເມື່ອ * ມູນຄ່າທີ່ແທ້ຈິງຂອງມັນ
ປ່ຽນແປງຢ່າງບັງຄັບ (ບໍ່ພຽງແຕ່ການອ້າງອີງ:

$d = $d + 1

ຈະສ້າງຜົນໄດ້ຮັບທີ່ແຕກຕ່າງກັນຫມົດ ($c ແລະ $d ຈະບໍ່ຖືກຜູກມັດອີກຕໍ່ໄປໃນຂະນະທີ່

$d .= $d + 1

ຈະໃຫ້ຜົນໄດ້ຮັບຄືກັນກັບ $d++), "ຄອບຄົວ" ປະກອບດ້ວຍ piddles ອື່ນໆທັງຫມົດທີ່ເຂົ້າຮ່ວມກັບ.
piddle mutated ໂດຍ​ການ​ຫັນ​ເປັນ​ສອງ​ວິ​ທີ​ການ​ແມ່ນ​ສ້າງ​ຕັ້ງ​ຂື້ນ​ແລະ​ທັງ​ຫມົດ​ທີ່​ຖືກ​ຄັດ​ລອກ​.

ທຸກໆຊິ້ນສ່ວນຫຼືການຫັນປ່ຽນທີ່ພຽງແຕ່ເລືອກຊຸດຍ່ອຍຂອງ pdl ຕົ້ນສະບັບແມ່ນສອງທາງ.
ມາຕຣິກເບື້ອງປີ້ນຄວນຈະເປັນ. ບໍ່ມີຕົວປະຕິບັດການເລກເລກ.

ແຫຼ່ງຂໍ້ມູນ

ສິ່ງ​ທີ່​ເຈົ້າ​ໄດ້​ບອກ​ໃນ​ພາກ​ກ່ອນ​ນີ້​ບໍ່​ແມ່ນ​ຄວາມ​ຈິງ​ທີ່​ຂ້ອນ​ຂ້າງ​: ພຶດ​ຕິ​ກໍາ​ທີ່​ອະ​ທິ​ບາຍ​ແມ່ນ​
ບໍ່ * ສະເຫມີ * ສິ່ງທີ່ທ່ານຕ້ອງການ. ບາງຄັ້ງທ່ານອາດຈະຢາກມີຂໍ້ມູນ "ແຫຼ່ງ":

$a = pdl 2,3,4; $b = pdl 5,6,7;
$ c = $ a + $ b;
ແຖວ($c);

ດຽວນີ້, ຖ້າເຈົ້າຮູ້ວ່າ $a ຈະປ່ຽນໄປ ແລະເຈົ້າຢາກໃຫ້ລູກຂອງເຈົ້າປ່ຽນໄປນຳ
ມັນ​, ທ່ານ​ສາ​ມາດ​ປະ​ກາດ​ມັນ​ເຂົ້າ​ໄປ​ໃນ​ແຫຼ່ງ​ຂໍ້​ມູນ (XXX ບໍ່​ໄດ້​ປະ​ຕິ​ບັດ​ໃນ​ສະ​ບັບ​ປະ​ຈຸ​ບັນ​)​:

$a->ແຫຼ່ງຂໍ້ມູນ(1)

ຫຼັງຈາກນັ້ນ, $a++ ຫຼື $a .= ບາງສິ່ງບາງຢ່າງຈະບໍ່ສ້າງຄອບຄົວໃຫມ່ແຕ່ຈະປ່ຽນແປງ $a ແລະຕັດ.
ຄວາມສໍາພັນຂອງມັນກັບພໍ່ແມ່ທີ່ຜ່ານມາ. ເດັກນ້ອຍທັງຫມົດຂອງມັນຈະປະຕິບັດຕາມມູນຄ່າປະຈຸບັນຂອງມັນ.

ດັ່ງນັ້ນຖ້າ $c ໃນສ່ວນທີ່ຜ່ານມາໄດ້ຖືກປະກາດວ່າເປັນແຫຼ່ງ, $e ແລະ $f ຈະຍັງຄົງຢູ່
ເທົ່າ​ທຽມ​ກັນ.

ຜູກມັດ

ກົນໄກການໄຫລຂອງຂໍ້ມູນຈະບໍ່ເປັນປະໂຫຍດຫຼາຍຖ້າບໍ່ມີຄວາມສາມາດໃນການຜູກມັດເຫດການ
ຂໍ້ມູນການປ່ຽນແປງ. ດັ່ງນັ້ນ, ພວກເຮົາສະຫນອງກົນໄກດັ່ງກ່າວ:

> $a = pdl 2,3,4
> $b = $a + 1;
> $c = $b * 2;
> $c->bind(ຍ່ອຍ {ພິມ "A now: $a, C now: $c\n" } )
> PDL::dowhenidle();
A ໃນປັດຈຸບັນ: [2,3,4], C ໃນປັດຈຸບັນ: [6 8 10]
> $a->set(0,1);
> $a->set(1,1);
> PDL::dowhenidle();
A ໃນປັດຈຸບັນ: [1,1,4], C ໃນປັດຈຸບັນ: [4 4 10]

ສັງເກດເຫັນວິທີການໂທກັບຄືນພຽງແຕ່ຖືກເອີ້ນໃນລະຫວ່າງ PDL::dowhenidle. ວິທີທີ່ງ່າຍໃນການໂຕ້ຕອບ
ນີ້ກັບກົນໄກການ Loop ເຫດການ Perl (ເຊັ່ນ: Tk) ກໍາລັງວາງແຜນ.

ມີຫຼາຍຊະນິດຂອງການນໍາໃຊ້ສໍາລັບຄຸນນະສົມບັດນີ້: ຕົວຢ່າງການປັບປຸງກາຟດ້ວຍຕົນເອງ.

Blah blah blah XXX ຄໍາອະທິບາຍເພີ່ມເຕີມ

ຂໍ້ຈໍາກັດ

Dataflow ດັ່ງກ່າວເປັນການເພີ່ມເຕີມທີ່ຈໍາກັດພໍສົມຄວນຢູ່ເທິງສຸດຂອງ Perl. ເພື່ອໃຫ້ໄດ້ຮັບການຫລອມໂລຫະຫຼາຍ
ນອກຈາກນັ້ນ, ພາຍໃນຂອງ Perl ຕ້ອງໄດ້ຮັບການ hack ເລັກນ້ອຍ. ການປະຕິບັດທີ່ແທ້ຈິງຈະ
ເຮັດໃຫ້ການໄຫຼເຂົ້າຂອງທຸກສິ່ງທຸກຢ່າງ, ລວມທັງ

ຂໍ້ມູນ
ຂະຫນາດຂໍ້ມູນ
ປະເພດຂໍ້ມູນ
ການດໍາເນີນງານ

ໃນປັດຈຸບັນພວກເຮົາມີພຽງແຕ່ສອງຄັ້ງທໍາອິດ (hey, 50% ໃນສອງສາມເດືອນແມ່ນບໍ່ບໍ່ດີ ;) ແຕ່.
ເຖິງແມ່ນວ່ານີ້ແມ່ນເປັນປະໂຫຍດໂດຍຕົວມັນເອງ. ຢ່າງໃດກໍຕາມ, ໂດຍສະເພາະອັນສຸດທ້າຍແມ່ນຕ້ອງການນັບຕັ້ງແຕ່ມັນ
ຈະເພີ່ມຄວາມເປັນໄປໄດ້ຂອງການໄຫຼປິດຈາກສະຖານທີ່ໄປຫາສະຖານທີ່ແລະຈະເຮັດໃຫ້ຈໍານວນຫຼາຍ
ສິ່ງທີ່ປ່ຽນແປງໄດ້ຫຼາຍຂຶ້ນ.

ເພື່ອເຮັດໃຫ້ສ່ວນທີ່ເຫຼືອເຮັດວຽກ, ພາຍໃນຂອງ dataflow ອາດຈະຈໍາເປັນຕ້ອງໄດ້ມີການປ່ຽນແປງເປັນ
ໂຄງ​ຮ່າງ​ທົ່ວ​ໄປ​ຫຼາຍ​ກວ່າ​.

ນອກຈາກນັ້ນ, ມັນຈະເປັນການດີທີ່ຈະສາມາດໄຫຼຂໍ້ມູນຕາມເວລາ, ຄ້າຍຄື lucid (ດັ່ງນັ້ນເຈົ້າສາມາດ
ໄດ້ຢ່າງງ່າຍດາຍກໍານົດທຸກປະເພດຂອງສິ່ງທີ່ປະມວນຜົນສັນຍານ).

ໃຊ້ PDL::Dataflowp ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net