@@ -5,6 +5,8 @@ using ConstructionBase: constructorof
5
5
using DiskArrays: DiskArrays, AbstractDiskArray, Unchunked, readblock!, writeblock!
6
6
using Serialization: deserialize, serialize
7
7
8
+ memory (a) = a
9
+
8
10
#
9
11
# AbstractSerializedArray
10
12
#
@@ -13,6 +15,9 @@ abstract type AbstractSerializedArray{T,N} <: AbstractDiskArray{T,N} end
13
15
const AbstractSerializedMatrix{T} = AbstractSerializedArray{T,2 }
14
16
const AbstractSerializedVector{T} = AbstractSerializedArray{T,1 }
15
17
18
+ memory (a:: AbstractSerializedArray ) = copy (a)
19
+ disk (a:: AbstractSerializedArray ) = a
20
+
16
21
function _copyto_write! (dst, src)
17
22
writeblock! (dst, src, axes (src)... )
18
23
return dst
@@ -30,11 +35,11 @@ function Base.copyto!(dst::AbstractArray, src::AbstractSerializedArray)
30
35
end
31
36
# Fix ambiguity error.
32
37
function Base. copyto! (dst:: AbstractSerializedArray , src:: AbstractSerializedArray )
33
- return copyto! (dst, copy (src))
38
+ return copyto! (dst, memory (src))
34
39
end
35
40
# Fix ambiguity error.
36
41
function Base. copyto! (dst:: AbstractDiskArray , src:: AbstractSerializedArray )
37
- return copyto! (dst, copy (src))
42
+ return copyto! (dst, memory (src))
38
43
end
39
44
# Fix ambiguity error.
40
45
function Base. copyto! (dst:: AbstractSerializedArray , src:: AbstractDiskArray )
@@ -45,26 +50,28 @@ function Base.copyto!(dst::PermutedDimsArray, src::AbstractSerializedArray)
45
50
return _copyto_read! (dst, src)
46
51
end
47
52
53
+ equals_serialized (a1, a2) = memory (a1) == memory (a2)
54
+
48
55
function Base.:(== )(a1:: AbstractSerializedArray , a2:: AbstractSerializedArray )
49
- return copy (a1) == copy ( a2)
56
+ return equals_serialized (a1, a2)
50
57
end
51
58
function Base.:(== )(a1:: AbstractArray , a2:: AbstractSerializedArray )
52
- return a1 == copy ( a2)
59
+ return equals_serialized (a1, a2)
53
60
end
54
61
function Base.:(== )(a1:: AbstractSerializedArray , a2:: AbstractArray )
55
- return copy (a1) == a2
62
+ return equals_serialized (a1, a2)
56
63
end
57
64
58
65
# # These cause too many ambiguity errors, try bringing them back.
59
66
# function Base.convert(arrayt::Type{<:AbstractSerializedArray}, a::AbstractArray)
60
67
# return arrayt(a)
61
68
# end
62
69
# function Base.convert(arrayt::Type{<:AbstractArray}, a::AbstractSerializedArray)
63
- # return convert(arrayt, copy (a))
70
+ # return convert(arrayt, memory (a))
64
71
# end
65
72
# # Fixes ambiguity error.
66
73
# function Base.convert(arrayt::Type{<:Array}, a::AbstractSerializedArray)
67
- # return convert(arrayt, copy (a))
74
+ # return convert(arrayt, memory (a))
68
75
# end
69
76
70
77
#
@@ -79,6 +86,8 @@ file(a::SerializedArray) = getfield(a, :file)
79
86
Base. axes (a:: SerializedArray ) = getfield (a, :axes )
80
87
arraytype (a:: SerializedArray{<:Any,<:Any,A} ) where {A} = A
81
88
89
+ disk (a:: AbstractArray ) = SerializedArray (a)
90
+
82
91
function SerializedArray (file:: String , a:: AbstractArray )
83
92
serialize (file, a)
84
93
ax = axes (a)
@@ -114,10 +123,10 @@ function DiskArrays.readblock!(
114
123
a:: SerializedArray{<:Any,N} , aout, i:: Vararg{AbstractUnitRange,N}
115
124
) where {N}
116
125
if i == axes (a)
117
- aout .= copy (a)
126
+ aout .= memory (a)
118
127
return a
119
128
end
120
- aout .= @view copy (a)[i... ]
129
+ aout .= @view memory (a)[i... ]
121
130
return a
122
131
end
123
132
function DiskArrays. writeblock! (
@@ -127,7 +136,7 @@ function DiskArrays.writeblock!(
127
136
serialize (file (a), ain)
128
137
return a
129
138
end
130
- a′ = copy (a)
139
+ a′ = memory (a)
131
140
a′[i... ] = ain
132
141
serialize (file (a), a′)
133
142
return a
@@ -171,7 +180,7 @@ function Base.similar(a::PermutedSerializedArray, elt::Type, dims::Tuple{Vararg{
171
180
end
172
181
173
182
function materialize (a:: PermutedSerializedArray )
174
- return PermutedDimsArray (copy (parent (a)), perm (a))
183
+ return PermutedDimsArray (memory (parent (a)), perm (a))
175
184
end
176
185
function Base. copy (a:: PermutedSerializedArray )
177
186
return copy (materialize (a))
241
250
# friendly on GPU. Consider special cases of strded arrays
242
251
# and handle with stride manipulations.
243
252
function Base. copy (a:: ReshapedSerializedArray{<:Any,<:Any,<:PermutedSerializedArray} )
244
- a′ = reshape (copy (parent (a)), axes (a))
253
+ a′ = reshape (memory (parent (a)), axes (a))
245
254
return a′ isa Base. ReshapedArray ? copy (a′) : a′
246
255
end
247
256
@@ -254,10 +263,10 @@ function DiskArrays.readblock!(
254
263
a:: ReshapedSerializedArray{<:Any,N} , aout, i:: Vararg{AbstractUnitRange,N}
255
264
) where {N}
256
265
if i == axes (a)
257
- aout .= copy (a)
266
+ aout .= memory (a)
258
267
return a
259
268
end
260
- aout .= @view copy (a)[i... ]
269
+ aout .= @view memory (a)[i... ]
261
270
return nothing
262
271
end
263
272
function DiskArrays. writeblock! (
@@ -267,7 +276,7 @@ function DiskArrays.writeblock!(
267
276
serialize (file (a), ain)
268
277
return a
269
278
end
270
- a′ = copy (a)
279
+ a′ = memory (a)
271
280
a′[i... ] = ain
272
281
serialize (file (a), a′)
273
282
return nothing
@@ -307,17 +316,17 @@ end
307
316
DiskArrays. haschunks (a:: SubSerializedArray ) = Unchunked ()
308
317
function DiskArrays. readblock! (a:: SubSerializedArray , aout, i:: OrdinalRange... )
309
318
if i == axes (a)
310
- aout .= copy (a)
319
+ aout .= memory (a)
311
320
end
312
- aout[i... ] = copy (view (a, i... ))
321
+ aout[i... ] = memory (view (a, i... ))
313
322
return nothing
314
323
end
315
324
function DiskArrays. writeblock! (a:: SubSerializedArray , ain, i:: OrdinalRange... )
316
325
if i == axes (a)
317
326
serialize (file (a), ain)
318
327
return a
319
328
end
320
- a_parent = copy (parent (a))
329
+ a_parent = memory (parent (a))
321
330
pinds = parentindices (view (a. sub_parent, i... ))
322
331
a_parent[pinds... ] = ain
323
332
serialize (file (a), a_parent)
@@ -349,7 +358,7 @@ function Base.similar(a::TransposeSerializedArray, elt::Type, dims::Tuple{Vararg
349
358
end
350
359
351
360
function materialize (a:: TransposeSerializedArray )
352
- return transpose (copy (parent (a)))
361
+ return transpose (memory (parent (a)))
353
362
end
354
363
function Base. copy (a:: TransposeSerializedArray )
355
364
return copy (materialize (a))
@@ -392,7 +401,7 @@ function Base.similar(a::AdjointSerializedArray, elt::Type, dims::Tuple{Vararg{I
392
401
end
393
402
394
403
function materialize (a:: AdjointSerializedArray )
395
- return adjoint (copy (parent (a)))
404
+ return adjoint (memory (parent (a)))
396
405
end
397
406
function Base. copy (a:: AdjointSerializedArray )
398
407
return copy (materialize (a))
@@ -445,7 +454,7 @@ Base.size(a::BroadcastSerializedArray) = size(a.broadcasted)
445
454
Base. broadcastable (a:: BroadcastSerializedArray ) = a. broadcasted
446
455
function Base. copy (a:: BroadcastSerializedArray )
447
456
# Broadcast over the materialized arrays.
448
- return copy (Base. Broadcast. broadcasted (a. broadcasted. f, copy .(a. broadcasted. args)... ))
457
+ return copy (Base. Broadcast. broadcasted (a. broadcasted. f, memory .(a. broadcasted. args)... ))
449
458
end
450
459
451
460
function Base. copy (broadcasted:: Broadcasted{SerializedArrayStyle{N}} ) where {N}
0 commit comments