Through the Interface

Parallelized pixelization inside AutoCAD using F#

As promised in the last post, we're now going to look at how to change the code to make the colour averaging routine work in parallel. The overall performance is marginally better on my dual-core machine, but I fully expect it to get quicker and quicker as the number of cores multiply.

To start with, though, here's the modified "synchronous" version of the code - as I went through making the code work in parallel, I noticed a bunch of general enhancements that were applicable to both versions. Here's the updated F# code:

// Use lightweight F# syntax

 

#light

 

// Declare a specific namespace and module name

 

module SyncPixelizer.Commands

 

// Import managed assemblies

 

#nowarn "9" // ... because we're using NativePtr

 

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.EditorInput

open Autodesk.AutoCAD.Geometry

open Autodesk.AutoCAD.Colors

open System.Drawing.Imaging

open Microsoft.FSharp.NativeInterop

 

// Add up the RGB values of a list of pixels

 

// We use a recursive function with an accumulator argument,

// (rt, gt, bt), to allow tail call optimization

 

let rec sumColors (pix : List<(byte*byte*byte)>) (rt,gt,bt) =

  match pix with

    | [] -> (rt, gt, bt)

    | (r, g, b) :: tl ->

        sumColors tl

          (rt + Byte.to_int r,

          gt + Byte.to_int g,

          bt + Byte.to_int b)

 

// Average out the RGB values of a list of pixels

 

let getAverageColour (pixels : List<(byte*byte*byte)>) =

  let (rsum, gsum, bsum) =

    sumColors pixels (0, 0, 0)

  let count = pixels.Length

  let ravg = Byte.of_int (rsum / count)

  let gavg = Byte.of_int (gsum / count)

  let bavg = Byte.of_int (bsum / count)

 

  // For some reason the pixel needs ro be reversed - probably

  // because of the bitmap format (needs investigation)

 

  Color.FromRgb(bavg, gavg, ravg)

 

// Function to get an index into our flat array

// from an x,y pair

 

let getIndexFromXY ysize x y =

  (x * ysize) + y

 

//  Get a chunk of pixels to average from one row

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkRowPixels p xsamp acc =

  if xsamp = 0 then

    acc

  else

    let pix =

      [(NativePtr.get p 0,

        NativePtr.get p 1,

        NativePtr.get p 2)]

    let p = NativePtr.add p 3 // We do *not* mutate here

    getChunkRowPixels p (xsamp-1) (pix @ acc)

 

// Get a chunk of pixels to average from multiple rows

 

// We use a recursive function with an accumulator argument

// to allow tail call optimization

 

let rec getChunkPixels p stride xsamp ysamp acc =

  if ysamp = 0 then

    acc

  else

    let pix = getChunkRowPixels p xsamp []

    let p = NativePtr.add p stride  // We do *not* mutate here

    getChunkPixels p stride xsamp (ysamp-1) (pix @ acc)

 

// Get the various chunks of pixels to average across

// a complete bitmap image

 

let pixelizeBitmap (image:System.Drawing.Bitmap) xsize ysize =

 

  // Create a 1-dimensional array of pixel lists (one list,

  // which then needs averaging, per final pixel)

 

  let (arr : List<(byte*byte*byte)>[]) =

    Array.create (xsize * ysize) []

 

  // Lock the entire memory block related to our image

 

  let bd =

    image.LockBits

      (System.Drawing.Rectangle

        (0, 0, image.Width ,image.Height),

      ImageLockMode.ReadOnly, image.PixelFormat)

 

  // Establish the number of pixels to sample per chunk

  // in each of the x and y directions

 

  let xsamp = image.Width / xsize

  let ysamp = image.Height / ysize

 

  // We have a mutable pointer to step through the image

 

  let mutable (p:nativeptr<byte>) =

    NativePtr.of_nativeint (bd.Scan0)

 

  // Loop through the various chunks

 

  for i = 0 to ysize - 1 do

 

    // We take a copy of the current value of p, as we

    // don't want to mutate p while extracting the pixels

    // within a row

 

    let mutable xp = p

    for j = 0 to xsize - 1 do

 

      // Get the square chunk of pixels starting at

      // this x,y position

 

      let chk =

        getChunkPixels xp bd.Stride xsamp ysamp []

 

      // Add it into our array

 

      let idx = getIndexFromXY ysize j (ysize-1-i)

      arr.[idx] <- chk

 

      // Mutate the pointer to move along to the right

      // by a value of 3 (our RGB value) times the

      // number of pixels we're sampling in x

 

      xp <- NativePtr.add xp (xsamp * 3)

    done

 

    // Mutate the original p pointer to move on one row

 

    p <- NativePtr.add p (bd.Stride * ysamp)

  done

 

  // Finally unlock the bitmap data and return the array

 

  image.UnlockBits(bd)

  arr

 

// Create an array of ObjectIds from a collection

 

let getIdArray (ids : ObjectIdCollection) =

  [| for i in [0..ids.Count-1] -> ids.[i] |]

 

// Declare our command

 

[<CommandMethod("pix")>]

let pixelize() =

 

  // Let's get the usual helpful AutoCAD objects

 

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

 

  // Prompt the user for the file and the width of the image

 

  let pofo =

    new PromptOpenFileOptions

      ("Select an image to import and pixelize")

  pofo.Filter <-

    "Jpeg Image (*.jpg)|*.jpg|All files (*.*)|*.*"

  let pfnr = ed.GetFileNameForOpen(pofo)

 

  let file =

    match pfnr.Status with

    | PromptStatus.OK ->

        pfnr.StringResult

    | _ ->

        ""

 

  if System.IO.File.Exists(file) then

 

    let img = System.Drawing.Image.FromFile(file)

 

    let pio =

      new PromptIntegerOptions

        ("\nEnter number of horizontal pixels: ")

    pio.AllowNone <- true

    pio.UseDefaultValue <- true

    pio.LowerLimit <- 1

    pio.UpperLimit <- img.Width

    pio.DefaultValue <- 100

 

    let pir = ed.GetInteger(pio)

    let xsize =

      match pir.Status with

        | PromptStatus.None ->

            img.Width

        | PromptStatus.OK ->

            pir.Value

        | _ -> -1

 

    if xsize > 0 then

 

      // Calculate the vertical size from the horizontal

 

      let ysize = img.Height * xsize / img.Width

 

      if ysize > 0 then

 

        // We'll time the command, so we can check the

        // sync vs. async efficiency

 

        let starttime = System.DateTime.Now

 

        // "use" has the same effect as "using" in C#

 

        use tr =

          db.TransactionManager.StartTransaction()

 

        // Get appropriately-typed BlockTable and BTRs

 

        let bt =

          tr.GetObject

            (db.BlockTableId,OpenMode.ForRead)

          :?> BlockTable

 

        let ms =

          tr.GetObject

            (bt.[BlockTableRecord.ModelSpace],

            OpenMode.ForWrite)

          :?> BlockTableRecord

 

        // Function to create a filled circle (hatch) at a

        // specific location

 

        // Note the valid use of tr and ms, as they are in scope

 

        let createCircle pt rad =

          let hat = new Hatch()

          hat.SetDatabaseDefaults()

          hat.SetHatchPattern

            (HatchPatternType.PreDefined,

            "SOLID")

 

          let id = ms.AppendEntity(hat)

          tr.AddNewlyCreatedDBObject(hat, true)

 

          // Now we create the loop, which we make db-resident

          // (appending a transient loop caused problems, so

          // we're going to use the circle and then erase it)

 

          let cir = new Circle()

          cir.Radius <- rad

          cir.Center <- pt

 

          let lid = ms.AppendEntity(cir)

          tr.AddNewlyCreatedDBObject(cir, true)

 

          // Have the hatch use the loop we created

 

          let loops = new ObjectIdCollection()

          loops.Add(lid) |> ignore

          hat.AppendLoop(HatchLoopTypes.Default, loops)

          hat.EvaluateHatch(true)

 

          // Now we erase the loop

 

          cir.Erase()

          id

 

        // Function to create our grid of circles

 

        let createGrid xsize ysize rad offset =

          let ids = new ObjectIdCollection()

          for i = 0 to xsize - 1 do

            for j = 0 to ysize - 1 do

              let pt =

                new Point3d

                  (offset * (Int32.to_float i),

                   offset * (Int32.to_float j),

                   0.0)

              let id = createCircle pt rad

              ids.Add(id) |> ignore

          ids

 

        // Function to change the colour of an entity

 

        let changeColour (id : ObjectId) (col : Color) =

          if id.IsValid then

            let ent =

              tr.GetObject(id, OpenMode.ForWrite) :?> Entity

            ent.Color <- col

 

        // Create our basic grid

 

        let ids = createGrid xsize ysize 0.5 1.2

 

        // Cast our image to a bitmap and then

        // get the chunked pixels

 

        let bmp = img :?> System.Drawing.Bitmap

        let arr = pixelizeBitmap bmp xsize ysize

 

        // Loop through the pixel list and average them out

        // (which could be parallelized), using the results

        // to change the colour of the circles in our grid

 

        Array.map getAverageColour arr |>

          Array.iter2 changeColour (getIdArray ids)

 

        // Commit the transaction

 

        tr.Commit()

 

        // Check how long it took

 

        let elapsed =

          System.DateTime.op_Subtraction

            (System.DateTime.Now, starttime)

 

        ed.WriteMessage

          ("\nElapsed time: " + elapsed.ToString())

To change this to run the colour averaging asynchronously (in parallel, if you have the cores) is really simple. We replace one line of code "Array.map getAverageColour arr" with the following:

Async.Run

  (Async.Parallel

    [ for a in arr ->

        async { return getAverageColour a }])

This essentially performs a parallel array map (albeit a somewhat naive one), returning basically the same results as the previous line - just hopefully a little more quickly. In case you want to build the two files into one project to test them side-by-side, here they are, the synchronous and asynchronous versions, with the changes needed to allow them to live in and execute from the same assembly.

Here's one more image that's been processed by the PIX command:

In case you're interested, the original image can be found here.

Implementing a simple graphing tool inside AutoCAD using F#

Well, I couldn't resist... as I mentioned in the last post - where we looked at creating a simple graph inside AutoCAD as an example of modifying objects inside nested transactions - the idea of graphing inside AutoCAD is a good fit for F#. This is for a number of reasons: F# is very mathematical in nature and excels at processing lists of data. I also spiced it up a bit by adding some code to parallelise some of the mathematical operations, but that didn't turn out to be especially compelling with my dual-core laptop. More on that later.

Here's the F# code:

// Use lightweight F# syntax

#light

// Declare a specific namespace and module name

module Grapher.Commands

// Import managed assemblies

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

open Autodesk.AutoCAD.Geometry

// Define a common normalization function which makes sure

// our graph gets mapped to our grid

let normalize fn normFn x minInp maxInp maxOut =

  let res =

    fn ((maxInp - minInp) * x / maxOut)

  let normRes = normFn res

  if normRes >= 0.0 && normRes <= 1.0 then

    normRes * (maxOut - 1.0)

  else

    -1.0

// Define some shortcuts to the .NET Math library

// trigonometry functions

let sin x = System.Math.Sin x

let cos x = System.Math.Cos x       

let tan x = System.Math.Tan x       

// Implement our own normalized trig functions

// which each map to the size of the grid passed in

let normSin max x =

  let nf a = (a + 1.0) / 2.0 // Normalise to 0-1

  let res =

    normalize

      sin nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

let normCos max x =

  let nf a = (a + 1.0) / 2.0 // Normalise to 0-1

  let res =

    normalize

      cos nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

let normTan max x =

  let nf a = (a + 3.0) / 6.0 // Normalise differently for tan

  let res =

    normalize

      tan nf (Int32.to_float x)

      0.0 (2.0 * System.Math.PI) (Int32.to_float max)

  Int32.of_float res

// Now we declare our command

[<CommandMethod("graph")>]

let gridCommand() =

  // We'll time the command, so we can check the

  // sync vs. async efficiency

  let starttime = System.DateTime.Now

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "use" has the same effect as "using" in C#

  use tr =

    db.TransactionManager.StartTransaction()

  // Get appropriately-typed BlockTable and BTRs

  let bt =

    tr.GetObject

      (db.BlockTableId,OpenMode.ForRead)

    :?> BlockTable

  let ms =

    tr.GetObject

      (bt.[BlockTableRecord.ModelSpace],

       OpenMode.ForWrite)

    :?> BlockTableRecord

  // Function to create a filled circle (hatch) at a

  // specific location

  // Note the valid use of tr and ms, as they are in scope

  let createCircle pt rad =

    let hat = new Hatch()

    hat.SetDatabaseDefaults();

    hat.SetHatchPattern

      (HatchPatternType.PreDefined,

       "SOLID")

    let id = ms.AppendEntity(hat)

    tr.AddNewlyCreatedDBObject(hat, true)

    // Now we create the loop, which we make db-resident

    // (appending a transient loop caused problems, so

    // we're going to use the circle and then erase it)

    let cir = new Circle()

    cir.Radius <- rad

    cir.Center <- pt

    let lid = ms.AppendEntity(cir)

    tr.AddNewlyCreatedDBObject(cir, true)

    // Have the hatch use the loop we created

    let loops = new ObjectIdCollection()

    loops.Add(lid) |> ignore

    hat.AppendLoop(HatchLoopTypes.Default, loops)

    hat.EvaluateHatch(true)

    // Now we erase the loop

    cir.Erase()

    id

  // Function to create our grid of circles

  let createGrid size rad offset =

    let ids = new ObjectIdCollection()

    for i = 0 to size - 1 do

      for j = 0 to size - 1 do

        let pt =

          new Point3d

            (offset * (Int32.to_float i),

            offset * (Int32.to_float j),

            0.0)

        let id = createCircle pt rad

        ids.Add(id) |> ignore

    ids

  // Function to change the colour of an entity

  let changeColour col (id : ObjectId) =

    if id.IsValid then

      let ent =

        tr.GetObject(id, OpenMode.ForWrite) :?> Entity

      ent.ColorIndex <- col

  // Shortcuts to make objects red and yellow

  let makeRed = changeColour 1

  let makeYellow = changeColour 2

  // Function to retrieve the contents of our

  // array of object IDs - this just calculates

  // the index based on the x & y values

  let getIndex fn size i =

    let res = fn size i

    if res >= 0 then

        (i * size) + res

    else

        -1

  // Apply our function synchronously for each value of x

  let applySyncBelowMax size fn =

    [| for i in [0..size-1] ->

       getIndex fn size i |]

  // Apply our function asynchronously for each value of x

  let applyAsyncBelowMax size fn =

    Async.Run

      (Async.Parallel

        [ for i in [0..size-1] ->

          async { return getIndex fn size i } ])

  // Hardcode the size of the grid and create it

  let size = 50

  let ids = createGrid size 0.5 1.2

  // Make the circles all red to start with

  Seq.iter makeRed (Seq.cast ids)

  // From a certain index in the list, get an object ID

  let getId i =

    if i >= 0 then

      ids.[i]

    else

      ObjectId.Null

  // Apply one of our trig functions, synchronously or

  // otherwise, to our grid

  applySyncBelowMax size normSin |>

    Array.map getId |>

      Array.iter makeYellow

  // Commit the transaction

  tr.Commit()

  // Check how long it took

  let elapsed =

      System.DateTime.op_Subtraction

        (System.DateTime.Now, starttime)

  ed.WriteMessage

    ("\nElapsed time: " +

    elapsed.ToString())

 

Here's what you see on AutoCAD's drawing canvas when you run the GRAPH command as it stands:

If you want to play around with other functions, you can edit the call to applySyncBelowMax to pass normCos or normTan instead of normSin.

 

As I mentioned earlier, if you swap the call to be applyAsyncBelowMax instead of applySyncBelowMax you will actually run the mathematics piece as asynchronous tasks. These are CPU-bound operations - they don't call across the network or write to a hard-drive, which might have increased the benefit of calling them asynchronously - so right now the async version actually runs more slowly than the sync version. If I were to have more processing cores available to me, it might also give us more benefit, but right now with my dual-core machine there's more effort spent coordinating the tasks than you gain from the parallelism. But I'll let you play around with that yourselves... you may get better results. One other note on that piece of the code: at some point I'd like to make use of the Parallel Extensions for .NET (in particular the Task Parallel Library (TPL)), but for now I've continued with what I know, the asynchronous worklows capability which is now standard in F#.

I'm travelling in India this week (and working from our Bangalore office next week), so this is likely to be my last post of the week.

AU Handouts: AutoCAD® .NET - Developing for AutoCAD® Using F# - Part 2

This post continues on from Part 1 of this series. You'll find much of this content has been used before in these previous posts, although post does include content updated for F# 1.9.6.2 (the September 2008 CTP).

The first thing we need to do is – as with any AutoCAD .NET project – add project references to AutoCAD’s managed assemblies, acmgd.dll and acdbmgd.dll. With F#’s integration into Visual Studio 2008 you do this in exactly the same way as you would for a C# or VB.NET project, by selecting Project -> Add Reference... from the pull-down menu or right-clicking the project inside the Solution Explorer and selecting Add Reference... from the context menu.

Here you then browse to the AutoCAD 2009 folder and filter for *mgd* files (at least this is the way I do it), and select the two we want:

Figure 10 – Adding project references to AutoCAD’s managed assemblies

Now we need to make sure AutoCAD recognizes a module within a namespace, from which it is able to load commands. I found – by using .NET Reflector – that the appropriate structure is to declare your functions as the contents of a module (this needs to come after the #light directive):

module MyNamespace.MyApplication

Next we’re going to specify the .NET namespaces we’ll be using inside this application:

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

We’ll then skip past our definitions of words and sortedWords, and define our command function:

[<CommandMethod("Words")>]

let listWords () =

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "use" has the same effect as "using" in C#

  use tr =

    db.TransactionManager.StartTransaction();

  // Get appropriately-typed BlockTable and BTRs

  let bt =

    tr.GetObject

      (db.BlockTableId,OpenMode.ForRead)

    :?> BlockTable

  let ms =

    tr.GetObject

      (bt.[BlockTableRecord.ModelSpace],

       OpenMode.ForRead)

    :?> BlockTableRecord

  let ps =

    tr.GetObject

      (bt.[BlockTableRecord.PaperSpace],

       OpenMode.ForRead)

    :?> BlockTableRecord

Most of this section should be familiar to anyone who has used the .NET API to AutoCAD – there are really only a couple of ideas that may need explanation:

1. The use keyword is just like C#’s using – but we don’t use curly braces to define scope. The scope gets defined as the remainder of the function in which the use statement has been used. Once the function completes the used object will be disposed of automatically.
2. We’re using the dynamic cast operator (:?>) to specify the type of object we’re opening with GetObject(). This operator involves a query to check whether this is valid – if we wanted to do a static cast we could use :> instead.

Now we have opened our modelspace and paperspace objects (we could go further and open other layouts, but – once again – I’ll leave that as a follow-on exercise for those who feel the need to do it :-) we can look at the code we need to extract the text from our database-resident objects.

Let’s start by defining a local function which takes an ObjectId and uses it to open an object, and for a textual object (DBText or MText) it will return its contents:

  // A function that accepts an ObjectId and returns

  // a list of the text contents, or an empty list.

  // Note the valid use of tr, as it is in scope

  let extractText x =

    let obj = tr.GetObject(x,OpenMode.ForRead)

    match obj with

    | :? MText as m -> m.Contents

    | :? DBText as d -> d.TextString

    | _ -> ""

Once again we haven’t specified the type of the argument – this will be inferred by the system – but we could very easily do so. We’re using the transaction previously started in the listWords function – the reason for defining extractText local to it – which is quite valid, as it’s in scope.

After opening the object for read from its ID we’re using pattern-matching – a technique that is a huge timesaver for functional programmers – to check on the type of the object and return the appropriate property of it. This is just like a much cleaner switch statement in C#.

We could choose to match against any property of the object, but in our case we want to check the type, so use this operator: :?. The as keyword is a syntactic shortcut that defines a value we can then use to easily dereference the object and get at its properties and methods.

The final clause of the three is a wildcard: it will match all object that are not DBText or MText objects and return an empty string.
Now that we can get at the contents of our text objects, let’s write a quick recursive function to display the contents of the final list of words inside AutoCAD:

  // A recursive function to print the contents of a list

  let rec printList x =

    match x with

    | h :: t -> ed.WriteMessage("\n" + h); printList t

    | [] -> ed.WriteMessage("\n")

Once again, this is a local function, so using our Editor (accessed via the ed value) is quite valid. We’re using pattern-matching again to create a recursive function (indicated via the rec keyword and then the recursive call to printList). When we find an empty list ([]) we simply print a newline, but when we find a list with a head (h) and a tail (t – which may well end up being empty, by the way, we’ll find out the next time we recurse into printList), we print the head and recurse with the tail.

One thing to look out for when defining recursive functions: they really need to be defined as tail-recursive, which means that the recursive call should be the last operation. This allows the compiler to perform tail call optimization, which replaces the declared recursion with a simply while loop inside the generated code.

Why does this matter? Well, calling a function does have some overhead, as stack space is required to store information about the function and its arguments, so if we have a list of 10,000 words to print and the function hasn’t been optimized, the recursion could cause problems. (The number could be 100,000 or 1,000,000, but the point is there is a number).

The above code does get optimized properly (even if the pattern for the empty list comes after the recursive call – it’s really about the position of the recursive call in the clause that recurses, rather than the overall program), and this is easy to check with .NET Reflector. In fact there’s an article on my blog covering just this:

http://through-the-interface.typepad.com/through_the_interface/2008/02/using-reflector.html

  Seq.to_list (Seq.cast ms) @    // Create a list of modelspace ids,

    Seq.to_list (Seq.cast ps) |> //  appending those from paperspace

    List.map extractText |>      // Extract the text from each object

    sortedWords |>               // Get a sorted, canonical list of words

    printList                    // Print the resultant words

A couple of comments on the above plumbing: ms and ps are both IEnumerable types (which correspond to the Seq class in F#), but are both untyped. This means we have to cast them, to be able to access them properly from F#, and then we can simply call Seq.to_list to get the contents into a list. The @ operator appends the list of ObjectIds of objects in modelspace with those in paperspace, and we then pipe the list into a call to List.map which runs our extractText function on all the objects in the combined list. The results get piped into our sortedWords function, and we finally print them to the command-line using our recursive printList function.

Finally, we’re just going to call commit on our transaction object, as for performance reasons this is currently best practice:

  // As usual, committing is cheaper than aborting

  tr.Commit()

That’s it for our first AutoCAD application. Let’s see the entire listing:

#light

// Declare a specific namespace and module name

module MyNamespace.MyApplication

open Autodesk.AutoCAD.Runtime

open Autodesk.AutoCAD.ApplicationServices

open Autodesk.AutoCAD.DatabaseServices

// Partial application of split which can then be

// applied to a string to retrieve the contained words

let words =

  let seps = " \t~`!@#$%^&*()-=_+{}|[]\\;':\"<>?,./"

  seps.ToCharArray() |> Array.to_list |> String.split

let sortedWords x =

    List.map words x |>  // Get the words from each string

    List.concat |>       // No need for the outer list

    Set.of_list |>       // Create a set from the list

    Set.to_list          // Create a list from the set

// Now we define our command

[<CommandMethod("Words")>]

let listWords () =

  // Let's get the usual helpful AutoCAD objects

  let doc =

    Application.DocumentManager.MdiActiveDocument

  let ed = doc.Editor

  let db = doc.Database

  // "use" has the same effect as "using" in C#

  use tr =

    db.TransactionManager.StartTransaction();

  // Get appropriately-typed BlockTable and BTRs

  let bt =

    tr.GetObject

      (db.BlockTableId,OpenMode.ForRead)

    :?> BlockTable

  let ms =

    tr.GetObject

      (bt.[BlockTableRecord.ModelSpace],

       OpenMode.ForRead)

    :?> BlockTableRecord

  let ps =

    tr.GetObject

      (bt.[BlockTableRecord.PaperSpace],

       OpenMode.ForRead)

    :?> BlockTableRecord

  // Now the fun starts...

  // A function that accepts an ObjectId and returns

  // a list of the text contents, or an empty list.

  // Note the valid use of tr, as it is in scope

  let extractText x =

    let obj = tr.GetObject(x,OpenMode.ForRead)

    match obj with

    | :? MText as m -> m.Contents

    | :? DBText as d -> d.TextString

    | _ -> ""

  // A recursive function to print the contents of a list

  let rec printList x =

    match x with

    | h :: t -> ed.WriteMessage("\n" + h); printList t

    | [] -> ed.WriteMessage("\n")

  // And here's where we plug everything together...

  Seq.to_list (Seq.cast ms) @    // Create a list of modelspace ids,

    Seq.to_list (Seq.cast ps) |> //  appending those from paperspace

    List.map extractText |>      // Extract the text from each object

    sortedWords |>               // Get a sorted, canonical list of words

    printList                    // Print the resultant words

  // As usual, committing is cheaper than aborting

  tr.Commit()

Introducing parallel processing in AutoCAD via F# Asynchronous Workflows

As mentioned previously, pure functional code lends itself to be run on multiple computing cores in parallel. While the tools aren’t yet there to make this happen automatically – via implicit parallelization – this is a likely outcome, over the coming years. For now we have the possibility of writing code that uses explicit parallelization – where we specify the tasks we know can be executed at the same time and leave the language and runtime to take care of the coordination.

There are a couple of ways to do this, right now: the Parallel Extensions to .NET (also in CTP stage and due for inclusion in Visual Studio 2010) provide a number of parallel constructs, such as parallel versions of for and while loops. F# currently provides the capability to define and execute Asynchronous Workflows, which is what we’re going to look at now.

First, let’s take a look at a sample application that we’re going to parallelize. This sample goes through and queries, via RSS, the latest posts on a number of different blogs. It then generates AutoCAD geometry – text with a hyperlink – for each of these posts. So we turn AutoCAD into an RSS reader, for all intents and purposes.

    1 // Use lightweight F# syntax

    2

    3 #light

    4

    5 // Declare a specific namespace and module name

    6

    7 module MyNamespace.MyApplication

    8

    9 // Import managed assemblies

   10

   11 open Autodesk.AutoCAD.Runtime

   12 open Autodesk.AutoCAD.ApplicationServices

   13 open Autodesk.AutoCAD.DatabaseServices

   14 open Autodesk.AutoCAD.Geometry

   15 open System.Xml

   16 open System.IO

   17 open System.Net

   18

   19 // The RSS feeds we wish to get. The first two values are

   20 // only used if our code is not able to parse the feed's XML

   21

   22 let feeds =

   23   [ ("Through the Interface",

   24     "http://blogs.autodesk.com/through-the-interface",

   25     "http://through-the-interface.typepad.com/through_the_interface/atom.xml");

   26

   27     ("Don Syme's F# blog",

   28     "http://blogs.msdn.com/dsyme/",

   29     "http://blogs.msdn.com/dsyme/rss.xml");

   30

   31     ("Shaan Hurley's Between the Lines",

   32     "http://autodesk.blogs.com/between_the_lines",

   33     "http://autodesk.blogs.com/between_the_lines/rss.xml");

   34

   35     ("Scott Sheppard's It's Alive in the Lab",

   36     "http://blogs.autodesk.com/labs",

   37     "http://labs.blogs.com/its_alive_in_the_lab/rss.xml");

   38

   39     ("Volker Joseph's Beyond the Paper",

   40     "http://blogs.autodesk.com/beyond_the_paper",

   41     "http://dwf.blogs.com/beyond_the_paper/atom.xml") ]

   42

   43 // Fetch the contents of a web page, synchronously

   44

   45 let httpSync (url:string) =

   46   let req = WebRequest.Create(url)

   47   use resp = req.GetResponse()

   48   use stream = resp.GetResponseStream()

   49   use reader = new StreamReader(stream)

   50   reader.ReadToEnd()

   51

   52 // Load an RSS feed's contents into an XML document object

   53 // and use it to extract the titles and their links

   54 // Hopefully these always match (this could be coded more

   55 // defensively)

   56

   57 let titlesAndLinks (name, url, xml) =

   58   try

   59     let xdoc = new XmlDocument()

   60     xdoc.LoadXml(xml)

   61

   62     let titles =

   63       [ for n in xdoc.SelectNodes("//*[name()='title']")

   64           -> n.InnerText ]

   65     let links =

   66       [ for n in xdoc.SelectNodes("//*[name()='link']") ->

   67           let inn = n.InnerText

   68           if  inn.Length > 0 then

   69             inn

   70           else

   71             let href = n.Attributes.GetNamedItem("href").Value

   72             let rel = n.Attributes.GetNamedItem("rel").Value

   73             if href.Contains("feedburner") or rel.Contains("enclosure") then

   74                 ""

   75             else

   76               href ]

   77

   78     let descs =

   79       [ for n in xdoc.SelectNodes

   80           ("//*[name()='description' or name()='subtitle' or name()='summary']")

   81             -> n.InnerText ]

   82

   83     // A local function to filter out duplicate entries in

   84     // a list, maintaining their current order.

   85     // Another way would be to use:

   86     //    Set.of_list lst |> Set.to_list

   87     // but that results in a sorted (probably reordered) list.

   88

   89     let rec nub lst =

   90       match lst with

   91       | a::[] -> [a]

   92       | a::b ->

   93         if a = List.hd b then

   94           nub b

   95         else

   96           a::nub b

   97       | [] -> []

   98

   99     // Filter the links to get (hopefully) the same number

  100     // and order as the titles and descriptions

  101

  102     let real = List.filter (fun (x:string) -> x.Length > 0) 

  103     let lnks = real links |> nub

  104

  105     // Return a link to the overall blog, if we don't have

  106     // the same numbers of titles, links and descriptions

  107

  108     let lnum = List.length lnks

  109     let tnum = List.length titles

  110     let dnum = List.length descs

  111

  112     if tnum = 0 || lnum = 0 || lnum <> tnum || dnum <> tnum then

  113       [(name,url,url)]

  114     else

  115       List.zip3 titles lnks descs

  116   with _ -> []

  117

  118 // For a particular (name,url) pair,

  119 // create an AutoCAD HyperLink object

  120

  121 let hyperlink (name,url,desc) =

  122   let hl = new HyperLink()

  123   hl.Name <- url

  124   hl.Description <- desc

  125   (name, hl)

  126

  127 // Download an RSS feed and return AutoCAD HyperLinks for its posts

  128

  129 let hyperlinksSync (name, url, feed) =

  130   let xml = httpSync feed

  131   let tl = titlesAndLinks (name, url, xml)

  132   List.map hyperlink tl

  133

  134 // Now we declare our command

  135

  136 [<CommandMethod("rss")>]

  137 let createHyperlinksFromRss() =

  138

  139   let starttime = System.DateTime.Now

  140

  141   // Let's get the usual helpful AutoCAD objects

  142

  143   let doc =

  144     Application.DocumentManager.MdiActiveDocument

  145   let ed = doc.Editor

  146   let db = doc.Database

  147

  148   // "use" has the same effect as "using" in C#

  149

  150   use tr =

  151     db.TransactionManager.StartTransaction()

  152

  153   // Get appropriately-typed BlockTable and BTRs

  154

  155   let bt =

  156     tr.GetObject

  157       (db.BlockTableId,OpenMode.ForRead)

  158     :?> BlockTable

  159   let ms =

  160     tr.GetObject

  161       (bt.[BlockTableRecord.ModelSpace],

  162        OpenMode.ForWrite)

  163     :?> BlockTableRecord

  164

  165   // Add text objects linking to the provided list of

  166   // HyperLinks, starting at the specified location

  167

  168   // Note the valid use of tr and ms, as they are in scope

  169

  170   let addTextObjects (pt : Point3d) lst =

  171     // Use a for loop, as we care about the index to

  172     // position the various text items

  173

  174     let len = List.length lst

  175     for index = 0 to len - 1 do

  176       let txt = new DBText()

  177       let (name:string,hl:HyperLink) = List.nth lst index

  178       txt.TextString <- name

  179       let offset =

  180         if index = 0 then

  181           0.0

  182         else

  183           1.0

  184

  185       // This is where you can adjust:

  186       //  the initial outdent (x value)

  187       //  and the line spacing (y value)

  188

  189       let vec =

  190         new Vector3d

  191           (1.0 * offset,

  192            -0.5 * (Int32.to_float index),

  193            0.0)

  194       let pt2 = pt + vec

  195       txt.Position <- pt2

  196       ms.AppendEntity(txt) |> ignore

  197       tr.AddNewlyCreatedDBObject(txt,true)

  198       txt.Hyperlinks.Add(hl) |> ignore

  199

  200   // Here's where we use the varous functions

  201   // we've defined

  202

  203   let links =

  204     List.map hyperlinksSync feeds

  205

  206   // Add the resulting objects to the model-space 

  207

  208   let len = List.length links

  209   for index = 0 to len - 1 do

  210

  211     // This is where you can adjust:

  212     //  the column spacing (x value)

  213     //  the vertical offset from origin (y axis)

  214

  215     let pt =

  216       new Point3d

  217         (15.0 * (Int32.to_float index),

  218         30.0,

  219         0.0)

  220     addTextObjects pt (List.nth links index)

  221

  222   tr.Commit()

  223

  224   let elapsed =

  225       System.DateTime.op_Subtraction(System.DateTime.Now, starttime)

  226

  227   ed.WriteMessage("\nElapsed time: " + elapsed.ToString())

I have numbered the lines, to make it easier for us to talk about the changes that are needed to introduce parallelism into this sample. Both synchronous and asynchronous versions of this application are available on my blog.

I won’t go through the above code in detail, here: firstly, it’s not intended as a perfect implementation of an RSS consumer – there are too many variations in the way RSS is implemented by different sites, so I know for a fact that this code will not work for certain blogs – it’s really intended to be an example of a – potentially time-consuming – asynchronous (in this case network-based) activity that is easy to run in parallel.

A word of caution: AutoCAD is not thread-safe – it is very much a single-threaded application – so we need to coordinate the results of these tasks prior to making the changes to the AutoCAD database. Luckily F# makes this very easy for us to do, so that’s really not a problem.

Here is the updated source that makes use of Asynchronous Workflows, with the modified/new lines highlighted in red (with a grey background for those reading this in black & white :-):

    1 // Use lightweight F# syntax

    2

    3 #light

    4

    5 // Declare a specific namespace and module name

    6

    7 module MyNamespace.MyApplicationAsync

    8

    9 // Import managed assemblies

   10

   11 open Autodesk.AutoCAD.Runtime

   12 open Autodesk.AutoCAD.ApplicationServices

   13 open Autodesk.AutoCAD.DatabaseServices

   14 open Autodesk.AutoCAD.Geometry

   15 open System.Xml

   16 open System.IO

   17 open System.Net

   18

   19 // The RSS feeds we wish to get. The first two values are

   20 // only used if our code is not able to parse the feed's XML

   21

   22 let feeds =

   23   [ ("Through the Interface",

   24     "http://blogs.autodesk.com/through-the-interface",

   25     "http://through-the-interface.typepad.com/through_the_interface/atom.xml");

   26

   27     ("Don Syme's F# blog",

   28     "http://blogs.msdn.com/dsyme/",

   29     "http://blogs.msdn.com/dsyme/rss.xml");

   30

   31     ("Shaan Hurley's Between the Lines",

   32     "http://autodesk.blogs.com/between_the_lines",

   33     "http://autodesk.blogs.com/between_the_lines/rss.xml");

   34

   35     ("Scott Sheppard's It's Alive in the Lab",

   36     "http://blogs.autodesk.com/labs",

   37     "http://labs.blogs.com/its_alive_in_the_lab/rss.xml");

   38

   39     ("Volker Joseph's Beyond the Paper",

   40     "http://blogs.autodesk.com/beyond_the_paper",

   41     "http://dwf.blogs.com/beyond_the_paper/atom.xml") ]

   42

   43 // Fetch the contents of a web page, asynchronously

   44

   45 let httpAsync(url:string) =

   46   async { let req = WebRequest.Create(url)

   47           use! resp = req.GetResponseAsync()

   48           use stream = resp.GetResponseStream()

   49           use reader = new StreamReader(stream)

   50           return reader.ReadToEnd() }

   51

   52 // Load an RSS feed's contents into an XML document object

   53 // and use it to extract the titles and their links

   54 // Hopefully these always match (this could be coded more

   55 // defensively)

   56

   57 let titlesAndLinks (name, url, xml) =

   58   try

   59     let xdoc = new XmlDocument()

   60     xdoc.LoadXml(xml)

   61

   62     let titles =

   63       [ for n in xdoc.SelectNodes("//*[name()='title']")

   64           -> n.InnerText ]

   65     let links =

   66       [ for n in xdoc.SelectNodes("//*[name()='link']") ->

   67           let inn = n.InnerText

   68           if  inn.Length > 0 then

   69             inn

   70           else

   71             let href = n.Attributes.GetNamedItem("href").Value

   72             let rel = n.Attributes.GetNamedItem("rel").Value

   73             if href.Contains("feedburner") or rel.Contains("enclosure") then

   74                 ""

   75             else

   76               href ]

   77

   78     let descs =

   79       [ for n in xdoc.SelectNodes

   80           ("//*[name()='description' or name()='subtitle' or name()='summary']")

   81             -> n.InnerText ]

   82

   83     // A local function to filter out duplicate entries in

   84     // a list, maintaining their current order.

   85     // Another way would be to use:

   86     //    Set.of_list lst |> Set.to_list

   87     // but that results in a sorted (probably reordered) list.

   88

   89     let rec nub lst =

   90       match lst with

   91       | a::[] -> [a]

   92       | a::b ->

   93         if a = List.hd b then

   94           nub b

   95         else

   96           a::nub b

   97       | [] -> []

   98

   99     // Filter the links to get (hopefully) the same number

  100     // and order as the titles and descriptions

  101

  102     let real = List.filter (fun (x:string) -> x.Length > 0) 

  103     let lnks = real links |> nub

  104

  105     // Return a link to the overall blog, if we don't have

  106     // the same numbers of titles, links and descriptions

  107

  108     let lnum = List.length lnks

  109     let tnum = List.length titles

  110     let dnum = List.length descs

  111

  112     if tnum = 0 || lnum = 0 || lnum <> tnum || dnum <> tnum then

  113       [(name,url,url)]

  114     else

  115       List.zip3 titles lnks descs

  116   with _ -> []

  117

  118 // For a particular (name,url) pair,

  119 // create an AutoCAD HyperLink object

  120

  121 let hyperlink (name,url,desc) =

  122   let hl = new HyperLink()

  123   hl.Name <- url

  124   hl.Description <- desc

  125   (name, hl)

  126

  127 // Use asynchronous workflows in F# to download

  128 // an RSS feed and return AutoCAD HyperLinks

  129 // corresponding to its posts

  130

  131 let hyperlinksAsync (name, url, feed) =

  132   async { let! xml = httpAsync feed

  133           let tl = titlesAndLinks (name, url, xml)

  134           return List.map hyperlink tl }

  135

  136 // Now we declare our command

  137

  138 [<CommandMethod("arss")>]

  139 let createHyperlinksFromRssAsync() =

  140

  141   let starttime = System.DateTime.Now

  142

  143   // Let's get the usual helpful AutoCAD objects

  144

  145   let doc =

  146     Application.DocumentManager.MdiActiveDocument

  147   let ed = doc.Editor

  148   let db = doc.Database

  149

  150   // "use" has the same effect as "using" in C#

  151

  152   use tr =

  153     db.TransactionManager.StartTransaction()

  154

  155   // Get appropriately-typed BlockTable and BTRs

  156

  157   let bt =

  158     tr.GetObject

  159       (db.BlockTableId,OpenMode.ForRead)

  160     :?> BlockTable

  161   let ms =

  162     tr.GetObject

  163       (bt.[BlockTableRecord.ModelSpace],

  164        OpenMode.ForWrite)

  165     :?> BlockTableRecord

  166

  167   // Add text objects linking to the provided list of

  168   // HyperLinks, starting at the specified location

  169

  170   // Note the valid use of tr and ms, as they are in scope

  171

  172   let addTextObjects (pt : Point3d) lst =

  173     // Use a for loop, as we care about the index to

  174     // position the various text items

  175

  176     let len = List.length lst

  177     for index = 0 to len - 1 do

  178       let txt = new DBText()

  179       let (name:string,hl:HyperLink) = List.nth lst index

  180       txt.TextString <- name

  181       let offset =

  182         if index = 0 then

  183           0.0

  184         else

  185           1.0

  186

  187       // This is where you can adjust:

  188       //  the initial outdent (x value)

  189       //  and the line spacing (y value)

  190

  191       let vec =

  192         new Vector3d

  193           (1.0 * offset,

  194            -0.5 * (Int32.to_float index),

  195            0.0)

  196       let pt2 = pt + vec

  197       txt.Position <- pt2

  198       ms.AppendEntity(txt) |> ignore

  199       tr.AddNewlyCreatedDBObject(txt,true)

  200       txt.Hyperlinks.Add(hl) |> ignore

  201

  202   // Here's where we do the real work, by firing

  203   // off - and coordinating - asynchronous tasks

  204   // to create HyperLink objects for all our posts

  205

  206   let links =

  207     Async.Run

  208       (Async.Parallel

  209         [ for (name,url,feed) in feeds ->

  210           hyperlinksAsync (name,url,feed) ])

  211     |> Array.to_list

  212

  213   // Add the resulting objects to the model-space 

  214

  215   let len = List.length links

  216   for index = 0 to len - 1 do

  217

  218     // This is where you can adjust:

  219     //  the column spacing (x value)

  220     //  the vertical offset from origin (y axis)

  221

  222     let pt =

  223       new Point3d

  224         (15.0 * (Int32.to_float index),

  225         30.0,

  226         0.0)

  227     addTextObjects pt (List.nth links index)

  228

  229   tr.Commit()

  230

  231   let elapsed =

  232       System.DateTime.op_Subtraction(System.DateTime.Now, starttime)

  233

  234   ed.WriteMessage("\nElapsed time: " + elapsed.ToString())

Let's look at the specific changes:

• Line 7 has been changed to allow both files to be part of the same project.
• Lines 45-50 implement a new, asynchronous function to download content from a URL. The async primitive coordinates a set of activities, while the let! and use! statements indicate that these right-hand side of the operation will be run asynchronously and that the results should be bound to the left. So here we're only getting the HTTP content asynchronously - the reading is to occur synchronously.
• Lines 131-134 implement an asynchronous task that not only calls our asynchronous HTTP request function but coordinates the creation of AutoCAD geometry based on the contents received.
• Lines 207-211 are where we make use of these newly-defined functions by firing them off in parallel (the framework will use the processing capabilities available to it to execute the tasks as efficiently as possible) and coordinating the results into a single array, which we convert to a list to maintain our previous processing code.

When we run either the RSS or ARSS (its asynchronous version), we should see this kind of result:

Figure 11 – AutoCAD geometry created from our RSS feeds

Now let’s see how they compare in terms of performance. I executed the RSS and ARSS commands a number of times in sequence to get a feel for relative performance.

Command: rss

Elapsed time: 00:00:08.1958195

Command: arss

Elapsed time: 00:00:02.2802280

Command: rss

Elapsed time: 00:00:04.1264126

Command: arss

Elapsed time: 00:00:03.6343634

Command: rss

Elapsed time: 00:00:03.6563656

Command: arss

Elapsed time: 00:00:01.9891989

Command: rss

Elapsed time: 00:00:03.1673167

Command: arss

Elapsed time: 00:00:03.1223122

Command: rss

Elapsed time: 00:00:05.7375737

Command: arss

Elapsed time: 00:00:01.9391939

The first execution time is much higher due to an initial startup penalty or the need to fill some page cache with the content. On average, though, the asynchronous code runs in 60-70% of the time needed by the synchronous version. The code was run a dual-core notebook: some of the performance will be related to using both cores, but most will be due to the parallelization of asynchronous tasks that have some latency due to use of the network. With more accesses in parallel you would see this performance difference become increasingly exaggerated.

Cleaning up after yourself: how and when to dispose of AutoCAD objects in .NET

A question came up recently in an internal discussion and I thought I'd share it as it proved so illuminating.

If I have an object of a type which implements IDisposable, is it good practice to explicitly dispose it (whether via the using statement or calling Dispose() explicitly)?

The quick(ish) answer is:

Yes it is, but sometimes you might choose not to as the increase in code simplicity outweighs the benefits derived from manually disposing of the objects.

So, naturally, the devil is in the detail. Let's take a look at the three scenarios where you're likely to be working with IDisposable objects inside AutoCAD:

1. Temporary objects - such as those provided by Autodesk.AutoCAD.Geometry - which are never Database-resident
2. Temporary objects with the potential to be database-resident but which never actually get added to a Database
3. Database-resident objects added/accessed via a Transaction

Below follows the details on each of these categories.

Temporary objects of types not derived from DBObject

The first category of temporary objects, such as Geometry.Line, are safe to be disposed of either "manually" (by your own code) or "automatically" (by the .NET garbage collector).

Temporary objects of DBObject-derived types

The second category of temporary objects, which are of a type derived from DBObject, must be disposed of manually. It is absolutely unsafe not to dispose of objects of DBObject-derived classes from the main execution thread in AutoCAD.

Why is this the case? Firstly, the majority of the classes available through AutoCAD's .NET API are currently unmanaged, with a relatively thin wrapper exposing them to the .NET world. Inside AutoCAD, all Database-resident objects are managed by a single-threaded runtime component, AcDb (which, along with some other components, is productized as Autodesk RealDWG). A side note: if you're using ObjectARX or RealDWG from C++, don't be confused by the fact your project's C-runtime memory management is likely to be "Multi-threaded DLL", RealDWG is not thread-aware and so must be treated as single-threaded, for all intents and purposes.

And - secondly - on to the reason that automatic garbage collection is not to be trusted on DBObject-derived types: the .NET garbage collector runs on a separate, typically low-priority - unless memory is running short - thread. So if a DBObject-derived type is garbage-collected inside AutoCAD, a separate thread will essentially call into a non thread-safe component (RealDWG), which is very, very likely to cause AutoCAD to crash.

So you must always call Dispose() on temporary objects of DBObject-derived classes in your .NET code - you cannot rely on the CLR to manage your objects'  lifetimes for you.

Interestingly, this is also the reason why the F# code I posted in this prior post will not effectively leverage multiple cores (something I've just tested since getting a multi-core machine). We are using a Ray (which is a DBObject-derived class) to get intersection points with our path, and then disposing of this temporary object from an arbitrary thread (farmed off via F# Asynchronous Workflows). So this is unsafe, and won't run for long before crashing. At least now I understand why.

Database-resident, Transaction-managed objects

The third category of objects are those we use a Transaction either to add to the Database or to open for access. The good news is that - as the Transaction is aware of the objects it manages (via calls to AddNewlyCreatedDBObject() or to GetObject()), it is able to dispose of them automatically when it, itself, is disposed. So the key here is to make sure you wrap your use of Transactions in using blocks or call Dispose() on them when you're done. There is no need to explicitly dispose of the objects managed by a Transaction (unless there is a failure between the time the object is created and when it is added to the transaction via AddNewlyCreatedDBObject(), of course).

A simple taxonomy of programming languages

Someone asked me recently how I categorize different programming paradigms. I thought it was a very interesting question, so here's what I responded. Please bear in mind that this is very much the way I see things, and is neither an exhaustive nor a formally-ratified taxonomy.

One way to look at languages is whether they're declarative or imperative:

Declarative programming languages map the way things are by building up “truths”: this category includes functional programming languages (such as Miranda, Haskell and Erlang) which tend to be mathematical in nature (you define equations) and start with lambda calculus as a foundation. The other main set of declarative languages are logic programming languages (such as Prolog), which start with propositional calculus as a foundation (you declare axioms that build up to a system against which you can run queries). Declarative languages tend to focus on describing the problem to solve, rather than how to solve it.

Imperative programming languages, on the other hand, are lists of instructions of what to do: I tend to consider procedural programming languages (such as C, COBOL, Fortran and Pascal) as a sub-category which focus on the definition and execution of sub-routines, while some people treat the terms imperative and procedural as synonyms.

Considering these definitions, object-oriented programming languages (such as Smalltalk and Eiffel) should probably be considered declarative, as conceptually they map real-world objects, but the truth is that the most popular OO languages (such as C++) are impure, and so most OO systems combine big chunks of procedural (i.e. imperative) code. Many people who think they’re doing OOP are actually packaging up procedures.

Note that I've tried not to list multi-paradigm languages such as Ada, C++ and F# in the above categorisation. It's possible that some of the languages I've listed are also multi-paradigm, but anyway.

One other way to think about languages is whether they’re top-down or bottom-up:

Bottom-up languages are ultimately layered on how a processor works (from machine code to assembly language to C & C++), while top-down languages start from the world of mathematics and logic and add language features that allow them to be used for programming (i.e. declarative languages are therefore top-down). This latter set of languages are starting to see increased adoption, as they assume much less (even nothing) about the underlying machinery, in which big changes are occurring with multiple processing cores being introduced (which essentially invalidate the assumptions of previous generations of programmers, who have been conditioned to think in terms of the processor's ability to store and access state).

Many popular - or soon to be popular - programming environments are pragmatic in nature: C++ allows OOP but can also be used for procedural programming, VB.NET now allows you to define and access objects while coming from a long line of procedural languages, F# is multi-paradigm, combining OO with functional and imperative programming.

There are bound to be people with differing views on this subject (and many of them are no doubt more intelligent and experienced in these matters than I), but this is how I would answer the question of how to categorise programming languages.

For those of you with an interest in the future of programming languages, I can strongly recommend the following Channel 9 episodes. If you're not aware of Channel 9, then prepare to be impressed: Microsoft has given a fantastic gift to the development community with this resource.

Burton Smith: On General Purpose Super Computing and the History and Future of Parallelism
Erik Meijer: Functional Programming
Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman: Software Composability and the Future of Languages
Brian Beckman: Don't fear the Monads
Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 1
Joe Armstrong - On Erlang, OO, Concurrency, Shared State and the Future, Part 2

Enjoy! :-)

Parallelizing robotic AutoCAD hatching with F# and .NET

In the last post we saw some code combining F# with C# to create a random "hatch" - a polyline path that bounces around within a boundary.

This post extends the code to make use of Asynchronous Workflows in F# to parallelize the testing of points along a segment. In the initial design of the application I decided to test 10 points along each segment, to see whether it remained entirely within our boundary: the idea being that this granularity makes it very likely the segment will fail the test, should it happen to leave the boundary at any point. Not 100% guaranteed, but a high probability event. What this code does is take the 10 tests and queue them up for concurrent processing (where the system is capable of it).

Asynchronous Workflows - as suggested by the name - were intended to fire off and manage asynchronous tasks (ones that access network resources, for instance). The segment testing activity is actually very local and processor-bound, so it's not really what the mechanism was intended for, but I thought it would be interesting to try. One interesting point: while testing this code I noticed that it actually ran slower on a single processor machine, which is actually quite logical: only one core is available for processing, so the amount of sequential processing is not reduced but the overhead of synchronizing the various tasks is added. So it was fairly inevitable it would take longer. In the post I first talked about Asynchronous Workflows I showed a sample that queried multiple RSS sites for data: even on a single processor machine this was significantly quicker, as parallelizing the network latency led to a clear gain.

Anyway, as it was slower on this machine I decided only to enable the parallel version of the code in cases where the computer's NUMBER_OF_PROCESSORS environment variable is greater than 1. I checked quickly on a colleague's dual-core machine, and sure enough this variable is set to 2 on his system. I haven't, however, tested the code on a dual- or multi-core system, but I'll be getting a new system in a matter of weeks, which will give me the chance to test it out.

Here's the F# code, with the line numbers highlighting the changes in red:

    1 // Use lightweight F# syntax

    2

    3 #light

    4

    5 // Declare a specific namespace and module name

    6

    7 module BounceHatchAsync.Commands

    8

    9 // Import managed assemblies

   10

   11 #I @"C:\Program Files\Autodesk\AutoCAD 2008"

   12 #I @".\PointInCurve\bin\Debug"

   13

   14 #r "acdbmgd.dll"

   15 #r "acmgd.dll"

   16

   17 #R "PointInCurve.dll" // R = CopyFile is true

   18

   19 open System

   20 open Autodesk.AutoCAD.Runtime

   21 open Autodesk.AutoCAD.ApplicationServices

   22 open Autodesk.AutoCAD.DatabaseServices

   23 open Autodesk.AutoCAD.EditorInput

   24 open Autodesk.AutoCAD.Geometry

   25 open PointInCurve

   26

   27 // Get a random vector on a plane

   28

   29 let randomUnitVector pl =

   30

   31   // Create our random number generator

   32   let ran = new System.Random()

   33

   34   // First we get the absolute value

   35   // of our x and y coordinates

   36

   37   let absx = ran.NextDouble()

   38   let absy = ran.NextDouble()

   39

   40   // Then we negate them, half of the time

   41

   42   let x = if (ran.NextDouble() < 0.5) then -absx else absx

   43   let y = if (ran.NextDouble() < 0.5) then -absy else absy

   44

   45   // Create a 2D vector and return it as

   46   //  3D on our plane

   47

   48   let v2 = new Vector2d(x, y)

   49   new Vector3d(pl, v2)

   50

   51 type traceType =

   52   | Accepted

   53   | Rejected

   54   | Superseded

   55

   56 // Draw one of three types of trace vector

   57

   58 let traceSegment (start:Point3d) (endpt:Point3d) trace =

   59

   60   let ed =

   61     Application.DocumentManager.MdiActiveDocument.Editor

   62

   63   let vecCol =

   64     match trace with

   65     | Accepted -> 3

   66     | Rejected -> 1

   67     | Superseded -> 2

   68   let trans =

   69     ed.CurrentUserCoordinateSystem.Inverse()

   70   ed.DrawVector

   71     (start.TransformBy(trans),

   72     endpt.TransformBy(trans),

   73     vecCol,

   74     false)

   75

   76 // Test a segment to make sure it is within our boundary

   77

   78 let testSegment cur (start:Point3d) (vec:Vector3d) =

   79

   80   // (This is inefficient, but it's not a problem for

   81   //  this application. Some of the redundant overhead

   82   //  of firing rays for each iteration could be factored

   83   //  out, among other enhancements, I expect.)

   84

   85   let pts =

   86     [for i in 1..10 -> start + (vec * 0.1 * Int32.to_float i)]

   87

   88   // Call into our IsInsideCurve library function,

   89   // "and"-ing the results

   90

   91   let inside pt =

   92     PointInCurve.Fns.IsInsideCurve(cur, pt)

   93

   94   List.for_all inside pts

   95

   96 // Test a segment to make sure it is within our boundary

   97

   98 let testSegmentAsync cur (start:Point3d) (vec:Vector3d) =

   99

  100   let pts =

  101     [for i in 1..10 -> start + (vec * 0.1 * Int32.to_float i)]

  102

  103   // Call into our IsInsideCurve library function,

  104   // "and"-ing the results

  105

  106   let inside pt =

  107     async { return PointInCurve.Fns.IsInsideCurve(cur, pt) }

  108

  109   let tests =

  110     Async.Run

  111       (Async.Parallel

  112         [for pt in pts -> inside pt])

  113

  114   Array.for_all (fun x -> x) tests

  115

  116 // For a particular boundary, get the next vertex on the

  117 // curve, found by firing a ray in a random direction

  118

  119 let nextBoundaryPoint (cur:Curve)

  120     (start:Point3d) trace runAsync =

  121

  122   // Get the intersection points until we

  123   // have at least 2 returned

  124   // (will usually happen straightaway)

  125

  126   let rec getIntersect (cur:Curve)

  127     (start:Point3d) vec =

  128

  129     let plane = cur.GetPlane()

  130

  131     // Create and define our ray

  132

  133     let ray = new Ray()

  134     ray.BasePoint <- start

  135     ray.UnitDir <- vec

  136

  137     let pts = new Point3dCollection()

  138     cur.IntersectWith

  139       (ray,

  140       Intersect.OnBothOperands,

  141       pts,

  142       0, 0)

  143

  144     ray.Dispose()

  145

  146     if (pts.Count < 2) then

  147       let vec2 = randomUnitVector plane

  148       getIntersect cur start vec2

  149     else

  150       pts

  151

  152   // For each of the intersection points - which

  153   // are points elsewhere on the boundary - let's

  154   // check to make sure we don't have to leave the

  155   // area to reach them

  156

  157   let plane =

  158     cur.GetPlane()

  159   let pts =

  160     randomUnitVector plane |> getIntersect cur start

  161

  162   // Get the distance between two points

  163

  164   let getDist fst snd =

  165     let (vec:Vector3d) = fst - snd

  166     vec.Length

  167

  168   // Compare two (dist, pt) tuples to allow sorting

  169   // based on the distance parameter

  170

  171   let compDist fst snd =

  172     let (dist1, pt1) = fst

  173     let (dist2, pt2) = snd

  174     if dist1 = dist2 then

  175       0

  176     else if dist1 < dist2 then

  177       -1

  178     else // dist1 > dist2

  179       1

  180

  181   // From the list of points we create a list

  182   // of (dist, pt) pairs, which we then sort

  183

  184   let sorted =

  185     [ for pt in pts -> (getDist start pt, pt) ] |>

  186       List.sort compDist

  187

  188   // A test function to check whether a segment

  189   // is within our boundary. It draws the appropriate

  190   // trace vectors, depending on success

  191

  192   let testItem dist =

  193     let (distval, pt) = dist

  194     let vec = pt - start

  195     if (distval > Tolerance.Global.EqualVector) then

  196       let res =

  197         if runAsync then

  198           testSegmentAsync cur start vec

  199         else

  200           testSegment cur start vec

  201       if res then

  202         if trace then

  203           traceSegment start pt traceType.Accepted

  204         Some(dist)

  205       else

  206         if trace then

  207           traceSegment start pt traceType.Rejected

  208         None

  209     else

  210       None

  211

  212   // Get the first item - which means the shortest

  213   // non-zero segment, as the list is sorted on distance

  214   // - that satisifies our condition of being inside

  215   // the boundary

  216

  217   let ret = List.first testItem sorted

  218   match ret with

  219   | Some(d,p) -> p

  220   | None -> failwith "Could not get point"

  221

  222 // We're using a different command name, so we can compare

  223

  224 [<CommandMethod("fba")>]

  225 let bounceHatch() =

  226   let doc =

  227     Application.DocumentManager.MdiActiveDocument

  228   let db = doc.Database

  229   let ed = doc.Editor

  230

  231   // Get various bits of user input

  232

  233   let getInput =

  234     let peo =

  235       new PromptEntityOptions

  236         ("\nSelect point on closed loop: ")

  237     let per = ed.GetEntity(peo)

  238     if per.Status <> PromptStatus.OK then

  239       None

  240     else

  241       let pio =

  242         new PromptIntegerOptions

  243           ("\nEnter number of segments: ")

  244       pio.DefaultValue <- 500

  245       let pir = ed.GetInteger(pio)

  246       if pir.Status <> PromptStatus.OK then

  247         None

  248       else

  249         let pko =

  250           new PromptKeywordOptions

  251             ("\nDisplay segment trace: ")

  252         pko.Keywords.Add("Yes")

  253         pko.Keywords.Add("No")

  254         pko.Keywords.Default <- "Yes"

  255         let pkr = ed.GetKeywords(pko)

  256         if pkr.Status <> PromptStatus.OK then

  257           None

  258         else

  259           Some

  260             (per.ObjectId,

  261             per.PickedPoint,

  262             pir.Value,

  263             pkr.StringResult.Contains("Yes"))

  264

  265   match getInput with

  266   | None -> ignore()

  267   | Some(oid, picked, numBounces, doTrace) ->

  268

  269     // Capture the start time for performance

  270     // measurement

  271

  272     let starttime = System.DateTime.Now

  273

  274     // We'll run asynchronously only when we have

  275     // multiple processing cores

  276

  277     let runAsync =

  278       (Int32.of_string

  279         (Environment.GetEnvironmentVariable

  280           ("NUMBER_OF_PROCESSORS")))

  281             > 1

  282

  283     use tr =

  284       db.TransactionManager.StartTransaction()

  285

  286     // Check the selected object - make sure it's

  287     // a closed loop (could do some more checks here)

  288

  289     let obj =

  290       tr.GetObject(oid, OpenMode.ForRead)

  291

  292     match obj with

  293     | :? Curve ->

  294       let cur = obj :?> Curve

  295       if cur.Closed then

  296         let latest =

  297           picked.

  298             TransformBy(ed.CurrentUserCoordinateSystem).

  299               OrthoProject(cur.GetPlane())

  300

  301         // Create our polyline path, adding the

  302         // initial vertex

  303

  304         let path = new Polyline()

  305         path.Normal <- cur.GetPlane().Normal

  306

  307         path.AddVertexAt

  308           (0,

  309           latest.Convert2d(cur.GetPlane()),

  310           0.0, 0.0, 0.0)

  311

  312         // A recursive function to get the points

  313         // for our path

  314

  315         let rec definePath start times =

  316           if times <= 0 then

  317             []

  318           else

  319             try

  320               let pt =

  321                 nextBoundaryPoint cur start doTrace runAsync

  322               (pt :: definePath pt (times-1))

  323             with exn ->

  324               if exn.Message = "Could not get point" then

  325                 definePath start times

  326               else

  327                 failwith exn.Message

  328

  329         // Another recursive function to add the vertices

  330         // to the path

  331

  332         let rec addVertices (path:Polyline)

  333           index (pts:Point3d list) =

  334

  335           match pts with

  336           | [] -> []

  337           | a::[] ->

  338             path.AddVertexAt

  339               (index,

  340               a.Convert2d(cur.GetPlane()),

  341               0.0, 0.0, 0.0)

  342             []

  343           | a::b ->

  344             path.AddVertexAt

  345               (index,

  346               a.Convert2d(cur.GetPlane()),

  347               0.0, 0.0, 0.0)

  348             addVertices path (index+1) b

  349

  350         // Plug our two functions together, ignoring

  351         // the results

  352

  353         definePath picked numBounces |>

  354           addVertices path 1 |>

  355             ignore

  356

  357         // Now we'll add our polyline to the drawing

  358

  359         let bt =

  360             tr.GetObject

  361               (db.BlockTableId,

  362               OpenMode.ForRead) :?> BlockTable

  363         let btr =

  364             tr.GetObject

  365               (bt.[BlockTableRecord.ModelSpace],

  366               OpenMode.ForWrite) :?> BlockTableRecord

  367

  368         // We need to transform the path polyline so

  369         // that it's over our boundary

  370

  371         path.TransformBy

  372           (Matrix3d.Displacement

  373             (cur.StartPoint - Point3d.Origin))

  374

  375         // Add our path to the modelspace

  376

  377         btr.AppendEntity(path) |> ignore

  378         tr.AddNewlyCreatedDBObject(path, true)

  379

  380         // Commit, whether we added a path or not.

  381

  382         tr.Commit()

  383

  384         // Print how much time has elapsed

  385

  386         let elapsed =

  387           System.DateTime.op_Subtraction

  388             (System.DateTime.Now, starttime)

  389

  390         ed.WriteMessage

  391           ("\nElapsed time: " + elapsed.ToString())

  392

  393         // If we're tracing, pause for user input

  394         // before regenerating the graphics

  395

  396         if doTrace then

  397           let pko =

  398             new PromptKeywordOptions

  399               ("\nPress return to clear trace vectors: ")

  400           pko.AllowNone <- true

  401           pko.AllowArbitraryInput <- true

  402           let pkr = ed.GetKeywords(pko)

  403           ed.Regen()

  404

  405     | _ ->

  406       ed.WriteMessage("\nObject is not a curve.")

Here's the the complete project which defines both FB and FBA commands for simple side-by-side comparison.

Using F# Asynchronous Workflows to simplify concurrent programming in AutoCAD

In the last post we saw some code that downloaded data - serially - from a number of websites via RSS and created AutoCAD entities linking to the various posts.

As promised, in today's post we take that code and enable it to query the same data in parallel by using Asynchronous Workflows in F#. Asynchronous Workflows are an easy-to-use yet powerful mechanism for enabling concurrent programming in F#.

Firstly, a little background as to why this type of technique is important. As many - if not all - of you are aware, the days of raw processor speed doubling every couple of years are over. The technical innovations that enabled Moore's Law to hold true for half a century are - at least in the area of silicon-based microprocessor design - hitting a wall (it's apparently called the Laws of Physics :-). Barring some disruptive technological development, the future gains in computing performance are to be found in the use of parallel processing, whether via multiple cores, processors or distributed clouds of computing resources.

Additionally, with an increasing focus on distributed computing and information resources, managing tasks asynchronously becomes more important, as information requests across a network inevitably introduce a latency that can be mitigated by the tasks being run in parallel.

The big problem is that concurrent programming is - for the most-part - extremely difficult to do, and even harder to retro-fit into existing applications. Traditional lock-based parallelism (where locks are used to control access to shared computing resources) is both unwieldy and prone to blocking. New technologies, such as Asynchronous Workflows and Software Transactional Memory, provide considerable hope (and this is a topic I have on my list to cover at some future point).

Today's post looks at a relatively simple scenario, in the sense that we want to perform a set of discrete tasks in parallel, harnessing those fancy multi-core systems for those of you lucky enough to have them (I'm hoping to get one when I next replace my notebook, sometime in March), but that these tasks are indeed independent: we want to wait until they are all complete, but we do not have the additional burden of them communicating amongst themselves or using shared resources (e.g. accessing shared memory) during their execution.

We are also going to be very careful only to run parallel tasks unrelated to AutoCAD. Any access made into AutoCAD's database, for instance, needs to be performed in series: AutoCAD is not thread-safe when it comes to the vast majority of its programmatically-accessible functionality. So we're going to run a set of asynchronous, parallel tasks to query our various RSS feeds, and combine the results before creating the corresponding geometry in AutoCAD. This all sounds very complex, but the good (actually great) news is that Asynchronous Workflows does all the heavy lifting. Phew.

Here's the modified F# code, with the modified/new lines coloured in red:

    1 // Use lightweight F# syntax

    2

    3 #light

    4

    5 // Declare a specific namespace and module name

    6

    7 module MyNamespace.MyApplication

    8

    9 // Import managed assemblies

   10

   11 #I @"C:\Program Files\Autodesk\AutoCAD 2008"

   12

   13 #r "acdbmgd.dll"

   14 #r "acmgd.dll"

   15

   16 open Autodesk.AutoCAD.Runtime

   17 open Autodesk.AutoCAD.ApplicationServices

   18 open Autodesk.AutoCAD.DatabaseServices

   19 open Autodesk.AutoCAD.Geometry

   20 open System.Xml

   21 open System.Collections

   22 open System.Collections.Generic

   23 open System.IO

   24 open System.Net

   25 open Microsoft.FSharp.Control.CommonExtensions

   26

   27 // The RSS feeds we wish to get. The first two values are

   28 // only used if our code is not able to parse the feed's XML

   29

   30 let feeds =

   31   [ ("Through the Interface",

   32     "http://blogs.autodesk.com/through-the-interface",

   33     "http://through-the-interface.typepad.com/through_the_interface/rss.xml");

   34

   35     ("Don Syme's F# blog",

   36     "http://blogs.msdn.com/dsyme/",

   37     "http://blogs.msdn.com/dsyme/rss.xml");

   38

   39     ("Shaan Hurley's Between the Lines",

   40     "http://autodesk.blogs.com/between_the_lines",

   41     "http://autodesk.blogs.com/between_the_lines/rss.xml");

   42

   43     ("Scott Sheppard's It's Alive in the Lab",

   44     "http://blogs.autodesk.com/labs",

   45     "http://labs.blogs.com/its_alive_in_the_lab/rss.xml");

   46

   47     ("Lynn Allen's Blog",

   48     "http://blogs.autodesk.com/lynn",

   49     "http://lynn.blogs.com/lynn_allens_blog/index.rdf");

   50

   51     ("Heidi Hewett's AutoCAD Insider",

   52     "http://blogs.autodesk.com/autocadinsider",

   53     "http://heidihewett.blogs.com/my_weblog/index.rdf") ]

   54

   55 // Fetch the contents of a web page, asynchronously

   56

   57 let httpAsync(url:string) =

   58   async { let req = WebRequest.Create(url)

   59           use! resp = req.GetResponseAsync()

   60           use stream = resp.GetResponseStream()

   61           use reader = new StreamReader(stream)

   62           return reader.ReadToEnd() }

   63

   64 // Load an RSS feed's contents into an XML document object

   65 // and use it to extract the titles and their links

   66 // Hopefully these always match (this could be coded more

   67 // defensively)

   68

   69 let titlesAndLinks (name, url, xml) =

   70   let xdoc = new XmlDocument()

   71   xdoc.LoadXml(xml)

   72

   73   let titles =

   74     [ for n in xdoc.SelectNodes("//*[name()='title']")

   75         -> n.InnerText ]

   76   let links =

   77     [ for n in xdoc.SelectNodes("//*[name()='link']") ->

   78         let inn = n.InnerText

   79         if  inn.Length > 0 then

   80           inn

   81         else

   82           let href = n.Attributes.GetNamedItem("href").Value

   83           let rel = n.Attributes.GetNamedItem("rel").Value

   84           if href.Contains("feedburner") then

   85               ""

   86           else

   87             href ]

   88

   89   let descs =

   90     [ for n in xdoc.SelectNodes

   91         ("//*[name()='description' or name()='content' or name()='subtitle']")

   92           -> n.InnerText ]

   93

   94   // A local function to filter out duplicate entries in

   95   // a list, maintaining their current order.

   96   // Another way would be to use:

   97   //    Set.of_list lst |> Set.to_list

   98   // but that results in a sorted (probably reordered) list.

   99

  100   let rec nub lst =

  101     match lst with

  102     | a::[] -> [a]

  103     | a::b ->

  104       if a = List.hd b then

  105         nub b

  106       else

  107         a::nub b

  108     | [] -> []

  109

  110   // Filter the links to get (hopefully) the same number

  111   // and order as the titles and descriptions

  112

  113   let real = List.filter (fun (x:string) -> x.Length > 0) 

  114   let lnks = real links |> nub

  115

  116   // Return a link to the overall blog, if we don't have

  117   // the same numbers of titles, links and descriptions

  118

  119   let lnum = List.length lnks

  120   let tnum = List.length titles

  121   let dnum = List.length descs

  122

  123   if tnum = 0 || lnum = 0 || lnum <> tnum || dnum <> tnum then

  124     [(name,url,url)]

  125   else

  126     List.zip3 titles lnks descs

  127

  128 // For a particular (name,url) pair,

  129 // create an AutoCAD HyperLink object

  130

  131 let hyperlink (name,url,desc) =

  132   let hl = new HyperLink()

  133   hl.Name <- url

  134   hl.Description <- desc

  135   (name, hl)

  136

  137 // Use asynchronous workflows in F# to download

  138 // an RSS feed and return AutoCAD HyperLinks

  139 // corresponding to its posts

  140

  141 let hyperlinksAsync (name, url, feed) =

  142   async { let! xml = httpAsync feed

  143           let tl = titlesAndLinks (name, url, xml)

  144           return List.map hyperlink tl }

  145

  146 // Now we declare our command

  147

  148 [<CommandMethod("rss")>]

  149 let createHyperlinksFromRss() =

  150

  151   // Let's get the usual helpful AutoCAD objects

  152

  153   let doc =

  154     Application.DocumentManager.MdiActiveDocument

  155   let db = doc.Database

  156

  157   // "use" has the same effect as "using" in C#

  158

  159   use tr =

  160     db.TransactionManager.StartTransaction()

  161

  162   // Get appropriately-typed BlockTable and BTRs

  163

  164   let bt =

  165     tr.GetObject

  166       (db.BlockTableId,OpenMode.ForRead)

  167     :?> BlockTable

  168   let ms =

  169     tr.GetObject

  170       (bt.[BlockTableRecord.ModelSpace],

  171       OpenMode.ForWrite)

  172     :?> BlockTableRecord

  173

  174   // Add text objects linking to the provided list of

  175   // HyperLinks, starting at the specified location

  176

  177   // Note the valid use of tr and ms, as they are in scope

  178

  179   let addTextObjects pt lst =

  180     // Use a for loop, as we care about the index to

  181     // position the various text items

  182

  183     let len = List.length lst

  184     for index = 0 to len - 1 do

  185       let txt = new DBText()

  186       let (name:string,hl:HyperLink) = List.nth lst index

  187       txt.TextString <- name

  188       let offset =

  189         if index = 0 then

  190           0.0

  191         else

  192           1.0

  193

  194       // This is where you can adjust:

  195       //  the initial outdent (x value)

  196       //  and the line spacing (y value)

  197

  198       let vec =

  199         new Vector3d

  200           (1.0 * offset,

  201           -0.5 * (Int32.to_float index),

  202           0.0)

  203       let pt2 = pt + vec

  204       txt.Position <- pt2

  205       ms.AppendEntity(txt) |> ignore

  206       tr.AddNewlyCreatedDBObject(txt,true)

  207       txt.Hyperlinks.Add(hl) |> ignore

  208

  209   // Here's where we do the real work, by firing

  210   // off - and coordinating - asynchronous tasks

  211   // to create HyperLink objects for all our posts

  212

  213   let links =

  214     Async.Run

  215       (Async.Parallel

  216         [ for (name,url,feed) in feeds ->

  217           hyperlinksAsync (name,url,feed) ])

  218

  219   // Add the resulting objects to the model-space 

  220

  221   let len = Array.length links

  222   for index = 0 to len - 1 do

  223

  224     // This is where you can adjust:

  225     //  the column spacing (x value)

  226     //  the vertical offset from origin (y axis)

  227

  228     let pt =

  229       new Point3d

  230         (15.0 * (Int32.to_float index),

  231         30.0,

  232         0.0)

  233     addTextObjects pt (Array.get links index)

  234

  235   tr.Commit()

You can download the new F# source file from here.

A few comments on the changes:

Lines 57-62 define our new httpAsync() function, which uses GetResponseAsync() - a function exposed in F# 1.9.3.7 - to download the contents of a web-page asynchronously [and which I stole shamelessly from Don Syme, who presented the code last summer at Microsoft's TechEd].

Lines 141-144 define another asynchronous function, hyperlinksAsync(), which calls httpAsync() and then - as before - extracts the feed information and creates a corresponding list of HyperLinks. This is significant: creation of AutoCAD HyperLink objects will be done on parallel; it is the addition of these objects to the drawing database that needs to be performed serially.

Lines 214-217 replace our very simple "map" with something slightly more complex: this code runs a list of tasks in parallel and waits for them all to complete before continuing. What is especially cool about this implementation is the fact that exceptions in individual tasks result in the overall task failing (a good thing, believe it or not :-), and the remaining tasks being terminated gracefully.

Lines 221 and 233 change our code to handle an array, rather than a list (while "map" previously returned a list, Async.Run returns an array).

When run, the code creates exactly the same thing as last time (although there are a few more posts in some of the blogs ;-)

A quick word on timing: I used "F# Interactive" to do a little benchmarking on my system, and even though it's single-core, single-processor, there was a considerable difference between the two implementations. I'll talk more about F# Interactive at some point, but think of it to F# in Visual Studio as the command-line is to LISP in AutoCAD: you can very easily test out fragments of F#, either by entering them directly into the F# Interactive window or highlighting them in Visual Studio's text editor and hitting Alt-Enter.

To enable function timing I entered "#time;;" (without the quotations marks) in the F# Interactive window. I then selected and loaded the supporting functions needed for each test - not including the code that adds the DBText objects with their HyperLinks to the database, as we're only in Visual Studio, not inside AutoCAD - and executed the "let links = ..." assignment in our two implementations of the createHyperlinksFromRss() function (i.e. the RSS command). These functions do create lists of AutoCAD HyperLinks, but that's OK: this is something works even outside AutoCAD, although we wouldn't be able to do anything much with them. Also, the fact we're not including the addition of the entities to the AutoCAD database is not relevant: by then we should have identical data in both versions, which would be added in exactly the same way.

Here are the results:

I executed the code for serial querying and parallel querying twice (to make sure there were no effects from page caching on the measurement):

val links : (string * HyperLink) list list

Real: 00:00:14.636, CPU: 00:00:00.15, GC gen0: 5, gen1: 1, gen2: 0

val links : (string * HyperLink) list array

Real: 00:00:06.245, CPU: 00:00:00.31, GC gen0: 3, gen1: 0, gen2: 0

val links : (string * HyperLink) list list

Real: 00:00:15.45, CPU: 00:00:00.46, GC gen0: 5, gen1: 1, gen2: 0

val links : (string * HyperLink) list array

Real: 00:00:03.832, CPU: 00:00:00.62, GC gen0: 2, gen1: 1, gen2: 0

So the serial execution took 14.5 to 15.5 seconds, while the parallel execution took 3.8 to 6.3 seconds.