High-Level Multithreading Part III, repeat

If you have missed the webinar on Thursday or if you couldn’t reconnect after the very unfortunate dropout, you can join the retransmission on Tuesday 2nd at 10.00 AM PDT / 19.00 CET. I’ll be going through the complete webinar for the purpose of recording so you can drop in conveniently late ;)
Registration link: https://www2.gotomeeting.com/register/535786066

State of the Software: BAD

Internet is a fragile, fragile thing. Listeners to my webinars know that.

Last time we got disconnected because of connection problems on my side.

Today, the webinar just ended. Listeners and presenters, we all just got the message that the organizer has ended the webinar. Well, he didn’t. He even restarted it and immediately got disconnected again with the same message :(

Sadly, we will not be able to finish the webinar today. I’m very very sorry for that.

Webinars–Reschedule and Recording

The code and slides for the Part I of the High-Level Multithreading webinar is available now at www.omnithreadlibrary.com/webinars.htm, as is the link to the downloadable video, which is being sold on Gumroad for $10.

Part II of the webinar was rescheduled for July 3rd. It will be transmitted at 15:30 CET / 9:30 EDT / 6:30 PDT / 23:30 AEST. Register here. Even if you were registered for the interrupted webinar, you'll have to register again.

If you are not yet registered for Part III yet (this Thursday at the same hour as rescheduled Part II), you can register here. Please keep in mind that all parts are independent – even if you missed part I, parts II and III will be completely understandable.

Webinar II Fail :(

I would like to apologize to everybody participating today for the technical difficulties. We had some storms in the area earlier before and they have affected internet connections more than I expected.

After a choppy first third of the webinar I completely lost connection and dropped out and now I cannot reconnect to the GoToWebinar at all. Sorry :(

We will repeat this webinar soon. I’ll post the new date here as soon as I know it.

Register for the OmniThreadLibrary Webinars!

Everything is set up and now you can register by clicking on the links below.

• Jun 20th: High-level multithreading, part I 
  Introduction to high-level abstractions, deeper look into Async/Await, Future and Join.
• Jun 24th: High-level multithreading, part II
  Quick overview of high-level abstractions, deeper look into ParallelTask, BackgroundWorker and Fork/Join.
• Jun 27th: High-level multithreading, part III
  Quick overview of high-level abstractions, deeper look into ForEach (parallel ‘for’) and Pipeline.

Each part will last about an hour and will start at 15:30 CET / 9:30 EDT / 6:30 PDT / 23:30 AEST.

Webinars will be available for the download. They will cost $10 each and bundles with reduced price will be available. Online webinars are free to attend.

DataSnap/FireDAC in Ljubljana

FireDAC/DataSnap was well visited in well accepted (and I also had a great time preparing it). Big thanks to everybody for attending!

Materials (in Slovenian language) are available here.

OmniThreadLibrary Webinars

Finally I am able to announce first OmniThreadLibrary Webinars. Due to the quantity of the material we decided to split the proposed two-part High-level Multithreading with OmniThreadLibrary into three parts. They will be transmitted as follows:

• Jun 20th: High-level multithreading, part I
  Introduction to high-level abstractions, deeper look into Async/Await, Future and Join.
• Jun 24th: High-level multithreading, part II 
  Quick overview of high-level abstractions, deeper look into ParallelTask, BackgroundWorker and Fork/Join.
• Jun 27th: High-level multithreading, part III
  Quick overview of high-level abstractions, deeper look into ForEach (parallel ‘for’) and Pipeline.

Each part will last about an hour and will start at 15:30 CET / 9:30 EDT / 6:30 PDT / 23:30 AEST.

Link to the registration form will appear shortly on this blog. It will also be sent to participants of the survey.

Embarcadero Academy: DataSnap and FireDAC

Next Wednesday (12th) I’ll be talking about modern data access technologies in RAD Studio XE4.

Register here.

XE4 for iOS in Slovenia

I just came home from the XE4/iOS presentation in Ljubljana and if I had to summarize the participant response it would be: “A very nice product, we’ll probably buy it when the Android is supported too.”

This (and a relatively small attendance) clearly shows that iOS is just not that popular in Slovenia. Even more, most of big Delphi-using companies in Slovenia have no interest in creating fresh, modern software and are still living in the “interesting, but we don’t need it” world :(

Thanks to everybody for coming to the presentation!

XE4 in Ljubljana

If you live in Slovenia and if you are programming in Delphi or C++Builder, make sure to reserve some time for the next Wednesday (22^nd) for the RAD Studio XE4 presentation in Ljubljana.

Most of the presentation will focus on the iOS development with RAD Studio XE4. More details here: Marand.

Results of the “Webinars” Survey

For Mason (and everybody else who might be interested), here are condensed results of the OmniThreadLibrary Webinars Survey.

OmniThreadLibrary Webinars

Results of the OmniThreadLibrary Webinars Survey are now in. 77 people cared enough to answer (thanks!) and from them the Random.org site selected the winner who will get a free copy of the Parallel Programming with OmniThreadLibrary book – Mr. Nigel Hughes. Congratulations to the winner!

Considering the results of the survey we have decided that the webinars will be free and that a copy of each webinar will be available for download for $10. First 20 downloads will also get a free copy of the OTL book, courtesy of De Novo software.

Exact dates/times for webinars will be announced later this month. Stay tuned!

Programación Paralela con OmniThreadLibrary

After a long wait, Programación Paralela con OmniThreadLibrary has been synchronized with the english version of the book. The book has now 209 pages and is considered to be 60% complete.

OmniThreadLibrary Webinars

In association with De Novo Software (www.denovosoftware.com) I am preparing a series of webinars about the multithreading and OmniThreadLibrary. Currently proposed topics are:

1. High-level multithreaded programming with the OmniThreadLibrary

This two part webinar will focus on high-level abstractions (Await, Future, ParallelTask, ForEach, Pipeline etc). In addition to the in-depth presentation of all eight high-level abstractions, the webinar will explore the blocking collection, a queue class extensively used in many high-level abstractions.

2. Low-level multithreaded programming with the OmniThreadLibrary

This webinar will focus on differences between the TThread (Delphi) and CreateTask (OmniThreadLibrary) model and will be intended for programmers that have no problems writing TThread-based code. If will firstly show what the OTL equivalents for the TThread operations are and then continue by exploring the parts of the OTL that have no TThread equivalent (such as writing background tasks without the main thread loop, communicating between the main thread and the task and so on.)

3. Using OmniThreadLibrary frameworks effectively

This webinar will focus on "backend" classes in the OTL - queues, locking primitives, TOmniValue record etc. All of these can be use in any application, single-threaded or multithreaded, TThread- or OTL-based to simplify programming and improve your productivity.

4. “Do's” and “Dont's” of multithreaded programming

This webinar will present best practices for the multithreaded programming. In addition to the abstract talk, it will contain numerous code examples to prove the point.

All of the webinars will be split into 45 minute presentation followed by the 15 minute Q&A part.

Interested?

To help me determine the best time for webinars and to assess the interest, I have put together a small survey. If you are interested in participating in a webinar or downloading it for your personal use, please fill out the survey. There are only seven questions, none of them mandatory.

All participants of the survey that will leave an email address will be entered into a draw to win a prize – a free copy of the OmniThreadLibrary book!

ThreadSafe Lock Manager: [3] Test

After you have designed and written some code, you should always test it. This is especially important for the multithreaded code which rarely works on the first (or the second, or third) try.

ThreadSafe Lock Manager: [2] Code

After explaining the design, I’ll continue my trip into the depths of the lock manager by exploring the actual code. Let’s take a look at the public parts first.

[This code is implemented in the OtlSync unit, which is part of the OmniThreadLibrary distribution. You’ll have to fetch the OTL from the SVN to use it.]

ThreadSafe Lock Manager: [1] Design

Few weeks ago I ran into a problem. I needed a thread-synchronizing code that would work similarly to a critical section, but would allow me to lock “anything”. If I could limit myself to objects, I could live with TMonitor.Enter/Exit, but I specifically wanted to limit access to some string keys. [In a way, my problem was similar to a problem of locking access to specific items in a string-keyed dictionary. Details differed, though.]

I was thinking about the problem and it turned out not to be a simple one. Yes, I could solve it by introducing a string-keyed dictionary of critical sections but that would be a little bit too limiting for my taste. I had some other requirements in mind which further complicated the implementation.

TL;DR – This lock manager is implemented in the OmniThreadLibrary as IOmniLockManager<K>/TOmniLockManager<K> in the OtlSync unit since revision 1268.

Using Generics to Manipulate Enumerated Types

I’d like to present a short class written by my colleague at work. Why? Because I just love how it uses the generics syntax to simplify some operations on enumerated types.

Like me, he hated the hoops one must jump through to convert an instance of an enumerated type to a string, to check if an integer value that was read from some storage contains a valid integer representation of some enumerated value and to enumerate (no pun intended) over such a type. Unlike me, he did something about that and wrote a Spring-inspired Range<T>.

Numbers I Should Keep In Mind

Name	Nanoseconds
L1 cache reference	0.5
Branch mispredict	5.0
L2 cache reference	7.0
Mutex lock/unlock	100.0
Main memory reference	100.0
Compress 1K bytes with Zippy	10,000.0
Send 2K bytes over 1 Gbps network	20,000.0
Read 1 MB sequentially from memory	250,000.0
Round trip within same datacenter	500,000.0
Rusty disk seek	10,000,000.0
Read 1 MB sequentially from network	10,000,000.0
Read 1 MB sequentially from disk	30,000,000.0
Send packet from CA->Netherlands->CA	150,000,000.0

From always excellent kellabyte.

Embarcadero Academy: The Power of XE3

Next Wednesday (March 13^th) we have organized a presentation for all users that are afraid to upgrade and are staying (for example) with Delphi 7. In “The Power of XE3” session I’ll go through all^* new features added to the Delphi and C++ Builder since Delphi 7 days. We’ll discuss language changes, platform changes, framework changes, additions to the VCL, RTL, database layer …

Register here.

---

^* As much as humanly possible. There are simply too many to cover them all.