Scale, Product Array Combinator

src/Finch.jl

@@ -37,14 +37,14 @@ export Scalar, SparseScalar, ShortCircuitScalar, SparseShortCircuitScalar
 export walk, gallop, follow, extrude, laminate
 export fiber, fiber!, Fiber!, pattern!, dropdefaults, dropdefaults!, redefault!
 export diagmask, lotrimask, uptrimask, bandmask
-export offset, permissive, protocolize, swizzle, toeplitz, window
+export scale, product, offset, permissive, protocolize, swizzle, toeplitz, window
 
 export choose, minby, maxby, overwrite, initwrite, d
 
 export default, AsArray
 
 export parallelAnalysis, ParallelAnalysisResults
-export parallel, extent, dimless
+export parallel, realextent, extent, dimless
 export CPU, CPULocalVector, CPULocalMemory
 
 export Limit
@@ -120,6 +120,8 @@ include("tensors/combinators/offset.jl")
 include("tensors/combinators/toeplitz.jl")
 include("tensors/combinators/windowed.jl")
 include("tensors/combinators/swizzle.jl")
+include("tensors/combinators/scale.jl")
+include("tensors/combinators/product.jl")
 
 
 include("traits.jl")

src/FinchNotation/FinchNotation.jl

@@ -37,7 +37,7 @@ module FinchNotation
 
     export getval, getname
 
-    export overwrite, initwrite, Dimensionless, dimless, extent
+    export overwrite, initwrite, Dimensionless, dimless, extent, realextent
 
     export d
 

src/FinchNotation/syntax.jl

@@ -96,6 +96,7 @@ overwrite(l, r) = r
 struct Dimensionless end
 const dimless = Dimensionless()
 function extent end
+function realextent end
 
 struct FinchParserVisitor
     nodes

src/dimensions.jl

@@ -40,15 +40,27 @@
     stop
 end
 
+@kwdef struct ContinuousExtent
+    start
+    stop
+end
+
 function virtual_call(::typeof(extent), ctx, start, stop)
     if isconstant(start) && isconstant(stop)
         Extent(start, stop)
     end
 end
+function virtual_call(::typeof(realextent), ctx, start, stop)
+    if isconstant(start) && isconstant(stop)
+        ContinuousExtent(start, stop)
+    end
+end
 
 virtual_uncall(ext::Extent) = call(extent, ext.start, ext.stop)
+virtual_uncall(ext::ContinuousExtent) = call(realextent, ext.start, ext.stop)
 
 FinchNotation.finch_leaf(x::Extent) = virtual(x)
+FinchNotation.finch_leaf(x::ContinuousExtent) = virtual(x)
 
 Base.:(==)(a::Extent, b::Extent) =
     a.start == b.start &&
@@ -162,6 +174,13 @@
         stop = call(+, ext.stop, delta)
     )
 end
+function shiftdim(ext::ContinuousExtent, delta)
+    ContinuousExtent(
+        start = call(+, ext.start, delta),
+        stop = call(+, ext.stop, delta)
+    )
+end
+
 
 shiftdim(ext::Dimensionless, delta) = dimless
 shiftdim(ext::ParallelDimension, delta) = ParallelDimension(ext, shiftdim(ext.ext, delta), ext.device)
@@ -174,6 +193,32 @@
     end
 end
 
+
+function scaledim(ext::Extent, scale)
+    Extent(
+        start = call(*, ext.start, scale),
+        stop = call(*, ext.stop, scale)
+    )
+end
+function scaledim(ext::ContinuousExtent, scale)
+    ContinuousExtent(
+        start = call(*, ext.start, scale),
+        stop = call(*, ext.stop, scale)
+    )
+end
+
+scaledim(ext::Dimensionless, scale) = dimless
+scaledim(ext::ParallelDimension, scale) = ParallelDimension(ext, scaledim(ext.ext, scale), ext.device)
+
+function scaledim(ext::FinchNode, body)
+    if ext.kind === virtual
+        scaledim(ext.val, body)
+    else
+        error("unimplemented")
+    end
+end
+
+
 #virtual_intersect(ctx, a, b) = virtual_intersect(ctx, promote(a, b)...)
 function virtual_intersect(ctx, a, b)
     println(a, b)
@@ -204,13 +249,6 @@
     )
 end
 
-@kwdef struct ContinuousExtent
-    start
-    stop
-end
-
-FinchNotation.finch_leaf(x::ContinuousExtent) = virtual(x)
-
 make_extent(::Type, start, stop) = throw(ArgumentError("Unsupported type"))
 make_extent(::Type{T}, start, stop) where T <: Integer = Extent(start, stop)
 make_extent(::Type{T}, start, stop) where T <: Real = ContinuousExtent(start, stop)

src/tensors/combinators/product.jl

@@ -0,0 +1,152 @@
+struct ProductArray{dim, Body} <: AbstractCombinator
+    body::Body
+end
+
+ProductArray(body, dim) = ProductArray{dim}(body)
+ProductArray{dim}(body::Body) where {dim, Body} = ProductArray{dim, Body}(body)
+
+Base.show(io::IO, ex::ProductArray) = Base.show(io, MIME"text/plain"(), ex)
+function Base.show(io::IO, mime::MIME"text/plain", ex::ProductArray{dim}) where {dim}
+	print(io, "ProductArray{$dim}($(ex.body))")
+end
+
+#Base.getindex(arr::ProductArray, i...) = ...
+
+struct VirtualProductArray <: AbstractVirtualCombinator
+    body
+    dim
+end
+
+function is_injective(lvl::VirtualProductArray, ctx)
+    sub = is_injective(lvl.body, ctx)
+    return [sub[1:lvl.dim]..., false, sub[lvl.dim + 1:end]...]
+end
+function is_concurrent(lvl::VirtualProductArray, ctx)
+    sub = is_concurrent(lvl.body, ctx)
+    return [sub[1:lvl.dim]..., false, sub[lvl.dim + 1:end]...]
+end
+is_atomic(lvl::VirtualProductArray, ctx) = is_atomic(lvl.body, ctx)
+
+Base.show(io::IO, ex::VirtualProductArray) = Base.show(io, MIME"text/plain"(), ex)
+function Base.show(io::IO, mime::MIME"text/plain", ex::VirtualProductArray)
+	print(io, "VirtualProductArray($(ex.body), $(ex.dim))")
+end
+
+Base.summary(io::IO, ex::VirtualProductArray) = print(io, "VProduct($(summary(ex.body)), $(ex.dim))")
+
+FinchNotation.finch_leaf(x::VirtualProductArray) = virtual(x)
+
+function virtualize(ex, ::Type{ProductArray{dim, Body}}, ctx) where {dim, Body}
+    VirtualProductArray(virtualize(:($ex.body), Body, ctx), dim)
+end
+
+products(body, dim) = ProductArray(body, dim)
+function virtual_call(::typeof(products), ctx, body, dim)
+    @assert isliteral(dim)
+    VirtualProductArray(body, dim.val)
+end
+
+virtual_uncall(arr::VirtualProductArray) = call(products, arr.body, arr.dim)
+
+lower(tns::VirtualProductArray, ctx::AbstractCompiler, ::DefaultStyle) = :(ProductArray($(ctx(tns.body)), $(tns.dim)))
+
+#virtual_size(arr::Fill, ctx::AbstractCompiler) = (dimless,) # this is needed for multidimensional convolution..
+#virtual_size(arr::Simplify, ctx::AbstractCompiler) = (dimless,)
+#virtual_size(arr::Furlable, ctx::AbstractCompiler) = (dimless,)
+
+function virtual_size(arr::VirtualProductArray, ctx::AbstractCompiler)
+    dims = virtual_size(arr.body, ctx)
+    return (dims[1:arr.dim - 1]..., dimless, dimless, dims[arr.dim + 1:end]...)
+end
+function virtual_resize!(arr::VirtualProductArray, ctx::AbstractCompiler, dims...)
+    virtual_resize!(arr.body, ctx, dims[1:arr.dim - 1]..., dimless, dims[arr.dim + 2:end]...)
+end
+
+function instantiate_reader(arr::VirtualProductArray, ctx, protos)
+    VirtualProductArray(instantiate_reader(arr.body, ctx, [protos[1:arr.dim]; protos[arr.dim + 2:end]]), arr.dim)
+end
+function instantiate_updater(arr::VirtualProductArray, ctx, protos)
+    VirtualProductArray(instantiate_updater(arr.body, ctx, [protos[1:arr.dim]; protos[arr.dim + 2:end]]), arr.dim)
+end
+
+(ctx::Stylize{<:AbstractCompiler})(node::VirtualProductArray) = ctx(node.body)
+function stylize_access(node, ctx::Stylize{<:AbstractCompiler}, tns::VirtualProductArray)
+    stylize_access(node, ctx, tns.body)
+end
+
+function popdim(node::VirtualProductArray, ctx)
+    if length(virtual_size(node, ctx)) == node.dim
+        return node.body
+    else
+        return node
+    end
+end
+
+truncate(node::VirtualProductArray, ctx, ext, ext_2) = VirtualProductArray(truncate(node.body, ctx, ext, ext_2), node.dim)
+
+function get_point_body(node::VirtualProductArray, ctx, ext, idx)
+    body_2 = get_point_body(node.body, ctx, ext, idx)
+    if body_2 === nothing
+        return nothing
+    else
+        return popdim(VirtualProductArray(body_2, node.dim), ctx)
+    end
+end
+
+(ctx::ThunkVisitor)(node::VirtualProductArray) = VirtualProductArray(ctx(node.body), node.dim)
+
+function get_run_body(node::VirtualProductArray, ctx, ext)
+    body_2 = get_run_body(node.body, ctx, ext)
+    if body_2 === nothing
+        return nothing
+    else
+        return popdim(VirtualProductArray(body_2, node.dim), ctx)
+    end
+end
+
+function get_acceptrun_body(node::VirtualProductArray, ctx, ext)
+    body_2 = get_acceptrun_body(node.body, ctx, ext)
+    if body_2 === nothing
+        return nothing
+    else
+        return popdim(VirtualProductArray(body_2, node.dim), ctx)
+    end
+end
+
+function (ctx::SequenceVisitor)(node::VirtualProductArray)
+    map(ctx(node.body)) do (keys, body)
+        return keys => VirtualProductArray(body, node.dim)
+    end
+end
+
+phase_body(node::VirtualProductArray, ctx, ext, ext_2) = VirtualProductArray(phase_body(node.body, ctx, ext, ext_2), node.dim)
+phase_range(node::VirtualProductArray, ctx, ext) = phase_range(node.body, ctx, ext)
+
+get_spike_body(node::VirtualProductArray, ctx, ext, ext_2) = VirtualProductArray(get_spike_body(node.body, ctx, ext, ext_2), node.dim)
+get_spike_tail(node::VirtualProductArray, ctx, ext, ext_2) = VirtualProductArray(get_spike_tail(node.body, ctx, ext, ext_2), node.dim)
+
+visit_fill(node, tns::VirtualProductArray) = visit_fill(node, tns.body)
+visit_simplify(node::VirtualProductArray) = VirtualProductArray(visit_simplify(node.body), node.dim)
+
+(ctx::SwitchVisitor)(node::VirtualProductArray) = map(ctx(node.body)) do (guard, body)
+    guard => VirtualProductArray(body, node.dim)
+end
+
+jumper_body(node::VirtualProductArray, ctx, ext) = VirtualProductArray(jumper_body(node.body, ctx, ext), node.dim)
+stepper_body(node::VirtualProductArray, ctx, ext) = VirtualProductArray(stepper_body(node.body, ctx, ext), node.dim)
+stepper_seek(node::VirtualProductArray, ctx, ext) = stepper_seek(node.body, ctx, ext)
+jumper_seek(node::VirtualProductArray, ctx, ext) = jumper_seek(node.body, ctx, ext)
+
+getroot(tns::VirtualProductArray) = getroot(tns.body)
+
+function unfurl(tns::VirtualProductArray, ctx, ext, mode, protos...)
+    if length(virtual_size(tns, ctx)) == tns.dim + 1
+        Unfurled(tns,
+            Lookup(
+                body = (ctx, idx) -> VirtualPermissiveArray(VirtualScaleArray(tns.body, ([literal(1) for _ in 1:tns.dim - 1]..., idx)), ([false for _ in 1:tns.dim - 1]..., true)), 
+            )
+        )
+    else
+        VirtualProductArray(unfurl(tns.body, ctx, ext, mode, protos...), tns.dim)
+    end
+end