Gitubrr · Gitubrr · Aug 12, 2025
diff --git a/Benchmarks/imProcB/Program.fs b/Benchmarks/imProcB/Program.fs
@@ -0,0 +1,55 @@
+namespace ImageProcessingB
+
+open System
+open BenchmarkDotNet.Attributes
+open BenchmarkDotNet.Running
+open BenchmarkDotNet.Configs
+open BenchmarkDotNet.Reports
+open Perfolizer.Horology
+
+open ImageProcessing.ImProcessing
+open SixLabors.ImageSharp.PixelFormats
+
+type ipBenchmark() =
+
+    static member Sizes = [|2; 4|]
+    member this.Random = System.Random()
+
+    [<ParamsSource("Sizes")>]
+    member val MatrixSize = 0 with get, set
+    member val MatrixToSort = Array2D.zeroCreate<Rgba32> 1 1 with get, set
+
+    [<IterationSetup>]
+    member this.GetArrayToSort () = 
+        this.MatrixToSort <- Array2D.init this.MatrixSize this.MatrixSize (fun _ _ -> 
+            let r = byte (this.Random.Next 256)
+            let g = byte (this.Random.Next 256)
+            let b = byte (this.Random.Next 256)
+            let a = byte (this.Random.Next 256)
+            Rgba32 (r, g, b, a)
+        ) 
+
+    [<Benchmark>]
+    member this.NoParallelism () = applyFilterNoParallelism gaussianBlur this.MatrixToSort
+
+    [<Benchmark>]
+    member this.PixelParallelism () = applyFilterPixelParallelism gaussianBlur this.MatrixToSort
+
+    [<Benchmark>]
+    member this.ParallelismInParts () = applyFilterParallelismInParts gaussianBlur this.MatrixToSort
+
+    [<Benchmark>]
+    member this.RowParallelism () = applyFilterRowParallelism gaussianBlur this.MatrixToSort
+
+    [<Benchmark>]
+    member this.ColParallelism () = applyFilterColParallelism gaussianBlur this.MatrixToSort
+
+
+module Main =
+    [<EntryPoint>]
+    let main argv =
+        let benchmarks =
+            BenchmarkSwitcher [| typeof<ipBenchmark> |]
+
+        benchmarks.Run argv |> ignore
+        0
diff --git a/Benchmarks/imProcB/imProcB.fsproj b/Benchmarks/imProcB/imProcB.fsproj
@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="Program.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.2" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.6" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\ImageProcessing\ImageProcessing.fsproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/HomeWork.sln b/HomeWork.sln
@@ -31,6 +31,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Benchmarks", "Benchmarks",
 EndProject
 Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "SortingsB", "Benchmarks\SortingsB\SortingsB.fsproj", "{B9D2A2D8-E4CD-40A4-B96F-211CA90A8865}"
 EndProject
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "imProcB", "Benchmarks\imProcB\imProcB.fsproj", "{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -84,6 +86,10 @@ Global
 		{B9D2A2D8-E4CD-40A4-B96F-211CA90A8865}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{B9D2A2D8-E4CD-40A4-B96F-211CA90A8865}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{B9D2A2D8-E4CD-40A4-B96F-211CA90A8865}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{F793D6BB-E68A-473E-B11F-1D7888DF4D4A} = {00DFC406-0A95-4C11-8BF2-4FD28C28061D}
@@ -97,5 +103,6 @@ Global
 		{C05FDC93-8EE3-442C-868A-031CE2A5F4E4} = {00DFC406-0A95-4C11-8BF2-4FD28C28061D}
 		{C42A6017-8A61-4469-8FCD-EEBF49198D80} = {B4AC50D2-34AD-46DF-B39E-FBCC5D0653C6}
 		{B9D2A2D8-E4CD-40A4-B96F-211CA90A8865} = {1BC2D310-CEB6-4FDE-9A59-D2D02DDA80E9}
+		{4E4C50C0-E167-4A95-BDA8-B6F5C88BCAE4} = {1BC2D310-CEB6-4FDE-9A59-D2D02DDA80E9}
 	EndGlobalSection
 EndGlobal
diff --git a/Tests/ImageProcessingT/PropertyImageProcessing.fs b/Tests/ImageProcessingT/PropertyImageProcessing.fs
@@ -18,12 +18,13 @@ module ImageGen =
             let a = byte 255
             return Rgba32(r, g, b, a)
         }
-    let array2DGen (size: int) : Gen<Rgba32[,]> =
+    let array2DGen (size: int) : Gen<Async<Rgba32[, ]>> = 
         gen {
             let! pixels = Gen.array2DOfDim (size, size) pixelGen
-            return pixels
+            return async { return pixels }
         }
-
+
+
 type Image100() =
     static member Rgba32() =
         Arb.fromGen (ImageGen.array2DGen 100)
@@ -37,40 +38,149 @@ type Image2() =
 type Filter() =
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.filterDoesntChangeSize (image: Rgba32[,]) =
-        let imageAfterFilter = applyFilter gaussianBlur image
-        Assert.Equal(100, imageAfterFilter.GetLength(0))
-        Assert.Equal(100, imageAfterFilter.GetLength(1))
+    member _.filterDoesntChangeSize (image: Async<Rgba32[, ]>) =
+        let resNoParallelism = 
+            applyFilterNoParallelismA gaussianBlur image
+            |> Async.RunSynchronously
+
+        let resPixelParallelism = 
+            applyFilterPixelParallelismA gaussianBlur image
+            |> Async.RunSynchronously
+
+        let resPartsParallelism = 
+            applyFilterParallelismInPartsA gaussianBlur image
+            |> Async.RunSynchronously
+
+        let resRowParallelism = 
+            applyFilterRowParallelismA gaussianBlur image
+            |> Async.RunSynchronously
+
+        let resColParallelism = 
+            applyFilterColParallelismA gaussianBlur image
+            |> Async.RunSynchronously
+
+        Assert.Equal(100, resNoParallelism.GetLength 0)
+        Assert.Equal(100, resNoParallelism.GetLength 1)
+
+        Assert.Equal(100, resPixelParallelism.GetLength 0)
+        Assert.Equal(100, resPixelParallelism.GetLength 1)
+
+        Assert.Equal(100, resPartsParallelism.GetLength 0)
+        Assert.Equal(100, resPartsParallelism.GetLength 1)
+
+        Assert.Equal(100, resRowParallelism.GetLength 0)
+        Assert.Equal(100, resRowParallelism.GetLength 1)
+
+        Assert.Equal(100, resColParallelism.GetLength 0)
+        Assert.Equal(100, resColParallelism.GetLength 1)
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.idDoesntChangeData (image: Rgba32[,]) =
-        let imageAfterFilter = applyFilter id image
-        Assert.Equal(image, imageAfterFilter)
+    member _.idDoesntChangeData (image: Async<Rgba32[, ]>) =
+        let resNoParallelism = applyFilterNoParallelismA id image
+        let resPixelParallelism = applyFilterPixelParallelismA id image
+        let resPartsParallelism = applyFilterParallelismInPartsA id image
+        let resRowParallelism = applyFilterRowParallelismA id image
+        let resColParallelism = applyFilterColParallelismA id image
+
+        Assert.Equal(image |> Async.RunSynchronously, resNoParallelism |> Async.RunSynchronously)
+        Assert.Equal(image |> Async.RunSynchronously, resPixelParallelism |> Async.RunSynchronously)
+        Assert.Equal(image |> Async.RunSynchronously, resPartsParallelism |> Async.RunSynchronously)
+        Assert.Equal(image |> Async.RunSynchronously, resRowParallelism |> Async.RunSynchronously)
+        Assert.Equal(image |> Async.RunSynchronously, resColParallelism |> Async.RunSynchronously)
 
     [<Property(Arbitrary = [| typeof<Image2> |])>]
-    member _.imageSmallerThanFilter (image: Rgba32[,]) =
-        let imageAfterFilter = applyFilter black image
-        Assert.Equal(true, imageIsBlack imageAfterFilter)
+    member _.imageSmallerThanFilter (image: Async<Rgba32[, ]>) =
+        let resNoParallelism = applyFilterNoParallelismA black image
+        let resPixelParallelism = applyFilterPixelParallelismA black image
+        let resPartsParallelism = applyFilterParallelismInPartsA black image
+        let resRowParallelism = applyFilterRowParallelismA black image
+        let resColParallelism = applyFilterColParallelismA black image
+
+        Assert.Equal(true, imageIsBlack resNoParallelism)
+        Assert.Equal(true, imageIsBlack resPixelParallelism)
+        Assert.Equal(true, imageIsBlack resPartsParallelism)
+        Assert.Equal(true, imageIsBlack resRowParallelism)
+        Assert.Equal(true, imageIsBlack resColParallelism)
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.blackFilter (image: Rgba32[,]) =
-        let imageBlack = applyFilter black image
-        Assert.Equal(true, imageIsBlack imageBlack)
+    member _.blackFilter (image: Async<Rgba32[, ]>) =
+        let imageBlack_NoParallelism = applyFilterNoParallelismA black image
+        let imageBlack_PixelParallelism = applyFilterPixelParallelismA black image
+        let imageBlack_PartsParallelism = applyFilterParallelismInPartsA black image
+        let imageBlac_RowParallelism = applyFilterRowParallelismA black image
+        let imageBlack_ColParallelism = applyFilterColParallelismA black image
+
+        Assert.Equal(true, imageIsBlack imageBlack_NoParallelism)
+        Assert.Equal(true, imageIsBlack imageBlack_PixelParallelism)
+        Assert.Equal(true, imageIsBlack imageBlack_PartsParallelism)
+        Assert.Equal(true, imageIsBlack imageBlac_RowParallelism)
+        Assert.Equal(true, imageIsBlack imageBlack_ColParallelism)
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.shiftComposition (image: Rgba32[,]) =
-        let trivial1and2 = applyFilter shiftRight image |> applyFilter shiftDown
-        let trivial12 = applyFilter shiftDiagonal image
-        Assert.Equal(trivial1and2, trivial12)
+    member _.shiftComposition (image: Async<Rgba32[, ]>) =
+        let trivial1and2_NoParallelism = applyFilterNoParallelismA shiftRight image |> applyFilterNoParallelismA shiftDown
+        let trivial12_NoParallelism = applyFilterNoParallelismA shiftDiagonal image
+
+        let trivial1and2_PixelParallelism = applyFilterPixelParallelismA shiftRight image |> applyFilterPixelParallelismA shiftDown
+        let trivial12_PixelParallelism = applyFilterPixelParallelismA shiftDiagonal image
+
+        let trivial1and2_PartsParallelism = applyFilterParallelismInPartsA shiftRight image |> applyFilterParallelismInPartsA shiftDown
+        let trivial12_PartsParallelism = applyFilterParallelismInPartsA shiftDiagonal image
+
+        let trivial1and2_RowParallelism = applyFilterRowParallelismA shiftRight image |> applyFilterRowParallelismA shiftDown
+        let trivial12_RowParallelism = applyFilterRowParallelismA shiftDiagonal image
+
+        let trivial1and2_ColParallelism = applyFilterColParallelismA shiftRight image |> applyFilterColParallelismA shiftDown
+        let trivial12_ColParallelism = applyFilterColParallelismA shiftDiagonal image
+
+        Assert.Equal(trivial1and2_NoParallelism |> Async.RunSynchronously, trivial12_NoParallelism |> Async.RunSynchronously)
+        Assert.Equal(trivial1and2_PixelParallelism |> Async.RunSynchronously, trivial12_PixelParallelism |> Async.RunSynchronously)
+        Assert.Equal(trivial1and2_PartsParallelism |> Async.RunSynchronously, trivial12_PartsParallelism |> Async.RunSynchronously)
+        Assert.Equal(trivial1and2_RowParallelism |> Async.RunSynchronously, trivial12_RowParallelism |> Async.RunSynchronously)
+        Assert.Equal(trivial1and2_ColParallelism |> Async.RunSynchronously, trivial12_ColParallelism |> Async.RunSynchronously)
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.extendedComposition (image: Rgba32[,])  =
-        let imageAfterFilter = applyFilter kernel image
-        let imageAfterExtendedFilter = applyFilter kernelExtended image
-        Assert.Equal(imageAfterFilter, imageAfterExtendedFilter)
+    member _.extendedComposition (image: Async<Rgba32[, ]>)  =
+        let imageAfterFilter_NoParallelism = applyFilterNoParallelismA kernel image 
+        let imageAfterExtendedFilter_NoParallelism = applyFilterNoParallelismA kernelExtended image
+
+        let imageAfterFilter_PixelParallelism = applyFilterPixelParallelismA kernel image
+        let imageAfterExtendedFilter_PixelParallelism = applyFilterPixelParallelismA kernelExtended image
+
+        let imageAfterFilter_PartsParallelism = applyFilterParallelismInPartsA kernel image
+        let imageAfterExtendedFilter_PartsParallelism = applyFilterParallelismInPartsA kernelExtended image
+
+        let imageAfterFilter_RowParallelism = applyFilterRowParallelismA kernel image
+        let imageAfterExtendedFilter_RowParallelism = applyFilterRowParallelismA kernelExtended image
+
+        let imageAfterFilter_ColParallelism = applyFilterColParallelismA kernel image
+        let imageAfterExtendedFilter_ColParallelism = applyFilterColParallelismA kernelExtended image
+
+        Assert.Equal(imageAfterFilter_NoParallelism |> Async.RunSynchronously, imageAfterExtendedFilter_NoParallelism |> Async.RunSynchronously)
+        Assert.Equal(imageAfterFilter_PixelParallelism |> Async.RunSynchronously, imageAfterExtendedFilter_PixelParallelism |> Async.RunSynchronously)
+        Assert.Equal(imageAfterFilter_PartsParallelism |> Async.RunSynchronously, imageAfterExtendedFilter_PartsParallelism |> Async.RunSynchronously)
+        Assert.Equal(imageAfterFilter_RowParallelism |> Async.RunSynchronously, imageAfterExtendedFilter_RowParallelism |> Async.RunSynchronously)
+        Assert.Equal(imageAfterFilter_ColParallelism |> Async.RunSynchronously, imageAfterExtendedFilter_ColParallelism |> Async.RunSynchronously)
 
     [<Property(Arbitrary = [| typeof<Image100> |])>]
-    member _.someAreCommutative (image: Rgba32[,]) =
-        let image12 = applyFilter shiftRight image |> applyFilter shiftDown
-        let image21 = applyFilter shiftDown image |> applyFilter shiftRight
-        Assert.Equal(image12, image21)
+    member _.someAreCommutative (image: Async<Rgba32[, ]>) =
+        let image12_NoParallelism = applyFilterNoParallelismA shiftRight image |> applyFilterNoParallelismA shiftDown
+        let image21_NoParallelism = applyFilterNoParallelismA shiftDown image |> applyFilterNoParallelismA shiftRight
+
+        let image12_PixelParallelism = applyFilterPixelParallelismA shiftRight image |> applyFilterPixelParallelismA shiftDown
+        let image21_PixelParallelism = applyFilterPixelParallelismA shiftDown image |> applyFilterPixelParallelismA shiftRight
+
+        let image12_PartsParallelism = applyFilterParallelismInPartsA shiftRight image |> applyFilterParallelismInPartsA shiftDown
+        let image21_PartsParallelism = applyFilterParallelismInPartsA shiftDown image |> applyFilterParallelismInPartsA shiftRight
+
+        let image12_RowParallelism = applyFilterRowParallelismA shiftRight image |> applyFilterRowParallelismA shiftDown
+        let image21_RowParallelism = applyFilterRowParallelismA shiftDown image |> applyFilterRowParallelismA shiftRight
+
+        let image12_ColParallelism = applyFilterColParallelismA shiftRight image |> applyFilterColParallelismA shiftDown
+        let image21_ColParallelism = applyFilterColParallelismA shiftDown image |> applyFilterColParallelismA shiftRight
+
+        Assert.Equal(image12_NoParallelism |> Async.RunSynchronously, image21_NoParallelism |> Async.RunSynchronously)
+        Assert.Equal(image12_PixelParallelism |> Async.RunSynchronously, image21_PixelParallelism |> Async.RunSynchronously)
+        Assert.Equal(image12_PartsParallelism |> Async.RunSynchronously, image21_PartsParallelism |> Async.RunSynchronously)
+        Assert.Equal(image12_RowParallelism |> Async.RunSynchronously, image21_RowParallelism |> Async.RunSynchronously)
+        Assert.Equal(image12_ColParallelism |> Async.RunSynchronously, image21_ColParallelism |> Async.RunSynchronously)