PDL :: Dataflowp - Trực tuyến trên đám mây

CHƯƠNG TRÌNH:

TÊN

PDL :: Luồng dữ liệu - mô tả triết lý luồng dữ liệu

SYNOPSIS

pdl> $ a = số XNUMX(10);
pdl> $ b = $ a-> lát ("2: 4: 2");
pdl> $ b ++;
pdl> print $ a;
[0 0 1 0 1 0 0 0 0 0]

CẢNH BÁO

Dataflow là rất thử nghiệm. Nhiều tính năng của nó bị vô hiệu hóa đối với 2.0, đặc biệt
họ cho luồng dữ liệu một hướng. Nếu bạn muốn sử dụng luồng dữ liệu một hướng cho
điều gì đó, vui lòng liên hệ với tác giả trước và chúng tôi sẽ tìm cách làm cho nó hoạt động
một lần nữa.

Luồng dữ liệu hai hướng (triển khai ->lát cắt() vv) là đầy đủ chức năng, tuy nhiên.
Chỉ về bất kỳ hàm nào trả về một số tập hợp con của các giá trị trong một số piddle sẽ tạo ra
ràng buộc vì vậy

$ a = một số trò chơi nhỏ
$ b = $ a-> slice ("một số bộ phận");
$ b-> set (3,3,10);

cũng thay đổi phần tử tương ứng trong $ a. $ b đã trở thành một cửa sổ cho một số
các phần tử con của $ a. Bạn cũng có thể xác định các quy trình của riêng mình để thực hiện các loại
tập hợp con. Nếu bạn không muốn $ b trở thành cửa sổ cho $ a, bạn phải làm

$ b = $ a-> lát ("một số bộ phận") -> sao chép;

Việc sao chép sẽ tắt tất cả luồng dữ liệu giữa hai piddles.

Những khó khăn với luồng dữ liệu một hướng liên quan đến các chuỗi như

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

nơi có một số kết quả có thể xảy ra và ngữ nghĩa có một chút âm u.

MÔ TẢ

Dataflow là mới đối với PDL2.0. Triết lý cơ bản đằng sau luồng dữ liệu là

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

nên làm việc. Nó không. Người ta cho rằng làm điều này có thể quá khó hiểu đối với
người mới và người dùng không thường xuyên của ngôn ngữ này. Do đó, bạn cần bật rõ ràng
luồng dữ liệu, vì vậy

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

tạo ra kết quả bất ngờ. Phần còn lại của tài liệu này giải thích các tính năng khác nhau và
chi tiết về việc triển khai luồng dữ liệu.

Lười biếng đánh giá

Khi bạn tính toán một cái gì đó như trên

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

sẽ không có gì được tính toán vào thời điểm này. Ngay cả bộ nhớ cho nội dung của $ b
chưa được phân bổ. Chỉ lệnh

> in $ b

thực sự sẽ làm cho $ b được tính toán. Điều quan trọng cần ghi nhớ khi thực hiện
các phép đo hiệu suất và điểm chuẩn cũng như khi theo dõi lỗi.

Có một lời giải thích cho hành vi này: nó có thể tiết kiệm chu kỳ nhưng quan trọng hơn,
hãy tưởng tượng như sau:

> $ a = pdl 2,3,4;
> $ b = pdl 5,6,7;
> $ c = $ a + $ b;
...
> $ a->thay đổi kích thước(4);
> $ b->thay đổi kích thước(4);
> in $ c;

Bây giờ, nếu $ c được đánh giá giữa hai lần thay đổi kích thước, một điều kiện lỗi là không tương thích
kích thước sẽ xảy ra.

Điều xảy ra trong phiên bản hiện tại là việc thay đổi kích thước $ a làm tăng cờ trong $ c:
"PDL_PARENTDIMSCHANGED" và $ b chỉ lại tăng cùng một cờ. Khi $ c được đánh giá tiếp theo,
các cờ được kiểm tra và thấy rằng cần phải tính toán lại.

Tất nhiên, đánh giá lười biếng đôi khi có thể làm cho việc gỡ lỗi trở nên khó khăn hơn vì lỗi có thể
xảy ra ở một nơi nào đó mà bạn không mong đợi chúng. Một dấu vết ngăn xếp tốt hơn cho các lỗi nằm trong
hoạt động cho PDL, có thể là do đó bạn có thể chuyển đổi công tắc $ PDL :: theo dõi và nhận được một
dấu vết của lỗi thực sự ở đâu.

Gia đình

Đây là một trong những khái niệm phức tạp hơn về luồng dữ liệu một hướng. Xem xét
mã sau ($ a và $ b là các pdls đã bật luồng dữ liệu):

$ c = $ a + $ b;
$ e = $ c + 1;
$ d = $ c-> đường chéo ();
$ d ++;
$ f = $ c + 1;

$ E và $ f nên chứa những gì bây giờ? Còn khi $ a bị thay đổi và tính toán lại thì sao
được kích hoạt.

Để làm cho luồng dữ liệu hoạt động như bạn mong đợi, một khái niệm khá lạ phải là
giới thiệu: gia đình. Hãy để chúng tôi tạo một sơ đồ:

ab
\ /
c
/|
/ |
ed

Đây là những gì PDL thực sự có trong bộ nhớ sau ba dòng đầu tiên. Khi $ d được thay đổi,
chúng ta muốn $ c thay đổi nhưng chúng ta không muốn $ e thay đổi vì nó đã có trên biểu đồ. Nó
Có thể bây giờ không rõ tại sao bạn không muốn nó thay đổi nhưng nếu có 40 dòng mã
giữa dòng thứ 2 và thứ 4, bạn sẽ. Vì vậy, chúng ta cần tạo một bản sao của $ c và $ d:

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

Lưu ý rằng chúng tôi đã đánh dấu c và d ban đầu, vì chúng không tương ứng với các đối tượng
bằng $ c và $ d nữa. Ngoài ra, hãy chú ý đến các đường chấm giữa hai đối tượng: khi $ a là
đã thay đổi và sơ đồ này được đánh giá lại, $ c thực sự nhận được giá trị của c 'với
đường chéo tăng dần.

Nói một cách tổng quát ở trên, bất cứ khi nào một piddle bị đột biến, tức là khi * giá trị * thực tế của nó là
bị thay đổi cưỡng bức (không chỉ là tham chiếu:

$ d = $ d + 1

sẽ tạo ra một kết quả hoàn toàn khác ($ c và $ d sẽ không bị ràng buộc nữa trong khi

$ d. = $ d + 1

sẽ mang lại kết quả giống như $ d ++), một "gia đình" bao gồm tất cả các piddles khác được tham gia vào
piddle đột biến bằng cách chuyển đổi hai chiều được tạo ra và tất cả những thứ đó đều được sao chép.

Tất cả các lát cắt hoặc phép biến đổi chỉ cần chọn một tập con của pdl ban đầu là hai chiều.
Ma trận nghịch đảo nên được. Không có toán tử số học nào.

nguồn

Những gì bạn đã được nói trong phần trước không hoàn toàn đúng: hành vi được mô tả là
không phải * luôn luôn * những gì bạn muốn. Đôi khi bạn có thể muốn có một "nguồn" dữ liệu:

$ a = pdl 2,3,4; $ b = pdl 5,6,7;
$ c = $ a + $ b;
dòng ($ c);

Bây giờ, nếu bạn biết rằng $ a sẽ thay đổi và bạn muốn con của nó thay đổi
nó, bạn có thể khai báo nó thành một nguồn dữ liệu (chưa hoàn thành XXX trong phiên bản hiện tại):

$ a->nguồn dữ liệu(1);

Sau đó, $ a ++ hoặc $ a. = Cái gì đó sẽ không tạo một họ mới nhưng sẽ thay đổi $ a và cắt
mối quan hệ của nó với cha mẹ trước đây của nó. Tất cả những đứa con của nó sẽ tuân theo giá trị hiện tại của nó.

Vì vậy, nếu $ c trong phần trước đã được khai báo là một nguồn, thì $ e và $ f sẽ vẫn
bình đẳng.

Binding

Cơ chế luồng dữ liệu sẽ không rất hữu ích nếu không có khả năng liên kết các sự kiện vào
dữ liệu đã thay đổi. Do đó, chúng tôi cung cấp một cơ chế như vậy:

> $ a = pdl 2,3,4
> $ b = $ a + 1;
> $ c = $ b * 2;
> $ c-> bind (sub {print "A now: $ a, C now: $ c \ n"})
> PDL :: dowhenidle ();
A bây giờ: [2,3,4], C bây giờ: [6 8 10]
> $ a-> set (0,1);
> $ a-> set (1,1);
> PDL :: dowhenidle ();
A bây giờ: [1,1,4], C bây giờ: [4 4 10]

Lưu ý cách gọi lại chỉ được gọi trong quá trình PDL :: dowhenidle. Một cách dễ dàng để giao diện
cơ chế vòng lặp sự kiện này đến Perl (chẳng hạn như Tk) đang được lên kế hoạch.

Có nhiều cách sử dụng cho tính năng này: ví dụ: đồ thị tự cập nhật.

Blah blah blah XXX giải thích thêm

Hạn chế

Dataflow như vậy là một bổ sung khá hạn chế trên Perl. Để có được một tinh tế hơn
Ngoài ra, nội bộ của Perl cần phải được hack một chút. Một triển khai thực sự sẽ
cho phép dòng chảy của mọi thứ, bao gồm

dữ liệu
kích thước dữ liệu
loại dữ liệu
hoạt động

Hiện tại, chúng tôi chỉ có hai lần đầu tiên (này, 50% trong một vài tháng không phải là xấu;) nhưng
ngay cả điều này cũng hữu ích bởi chính nó. Tuy nhiên, đặc biệt là cái cuối cùng đáng mong đợi vì nó
sẽ thêm khả năng đóng cửa luân chuyển từ nơi này sang nơi khác và sẽ tạo ra nhiều
mọi thứ linh hoạt hơn.

Để phần còn lại hoạt động, phần bên trong của luồng dữ liệu có thể cần được thay đổi để trở thành
khuôn khổ chung hơn.

Ngoài ra, sẽ rất tuyệt nếu có thể truyền dữ liệu đúng lúc, giống như sáng suốt (vì vậy bạn có thể
dễ dàng xác định tất cả các loại điều xử lý tín hiệu).

Sử dụng PDL :: Dataflowp trực tuyến bằng các dịch vụ onworks.net