Technical Writings
- C++ Concurrency Book
- Articles and Publications
- Conference Presentations
- Recent Blog Entries
- Multithreading Blog Entries
- C++ Blog Entries
Subscribe to Blog
Blog Archives
Blog Archive for / news /
10th Anniversary Sale - last few days
Wednesday, 29 July 2015
The last few days of our 10th Anniversary Sale are upon us. Just::Thread and Just::Thread Pro are available for 50% off the normal price until 31st July 2015.
Just::Thread is our implementation of the C++11 and C++14 thread libraries, for Windows, Linux and MacOSX. It also includes some of the extensions from the upcoming C++ Concurrency TS, with more to come shortly.
Just::Thread Pro is our add-on library which provides an Actor framework for easier concurrency, along with concurrent data structures: a thread-safe queue, and concurrent hash map, and a wrapper for ensuring synchronized access to single objects.
All licences include a free upgrade to point releases, so if you purchase now you'll get a free upgrade to all 2.x releases.
Coming soon in v2.2
The V2.2 release of Just::Thread will be out soon. This will include the new facilities from the Concurrency TS:
Some features from the concurrency TS are already in V2.1:
All customers with V2.x licenses, including those purchased during the sale, will get a free upgrade to V2.2 when it is released.
Posted by Anthony Williams
[/ news /] permanent link
Tags: sale
Stumble It! 
| Submit to Reddit 
| Submit to DZone 
If you liked this post, why not subscribe to the RSS feed 
or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
10th Anniversary Sale
Wednesday, 01 July 2015
We started Just Software Solutions Ltd in June 2005, so we've now been in business for 10 years. We're continuing to thrive, with both our consulting, training and development services, and sales of Just::Thread doing well.
To let our customers join in with our celebrations, we're running a month long sale: for the whole of July 2015, Just::Thread and Just::Thread Pro will be available for 50% off the normal price.
Just::Thread is our implementation of the C++11 and C++14 thread libraries, for Windows, Linux and MacOSX. It also includes some of the extensions from the upcoming C++ Concurrency TS, with more to come shortly.
Just::Thread Pro is our add-on library which provides an Actor framework for easier concurrency, along with concurrent data structures: a thread-safe queue, and concurrent hash map, and a wrapper for ensuring synchronized access to single objects.
All licences include a free upgrade to point releases, so if you purchase now you'll get a free upgrade to all 2.x releases.
Posted by Anthony Williams
[/ news /] permanent link
Tags: sale
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
Slides and code and for my ACCU 2015 presentation
Wednesday, 17 June 2015
It's now two months since the ACCU 2015 conference in Bristol, UK, so I thought it was about time I posted my slides.
This year my presentation was titled "Safety: off - How not to shoot yourself in the foot with C++ atomics". I gave a brief introduction to the C++ atomics facilities, some worked examples of usage, and guidelines for how to use atomics safely in your code.
The slides are available here, and the code examples here.
Posted by Anthony Williams
[/ news /] permanent link
Tags: C++, lockfree, atomic, accu
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
just::thread C++11 and C++14 Thread Library V2.1 released
Tuesday, 03 March 2015
I am pleased to announce that version 2.1 of
just::thread, our C++11 and C++14 Thread Library
has just been released with support for new compilers.
This release adds the long-awaited support for gcc 4.8 on MacOSX, as well as bringing linux support right up to date with support for gcc 4.9 on Ubuntu and Fedora.
Just::Thread is now supported for the following compilers:
- Microsoft Windows XP and later:
- Microsoft Visual Studio 2005, 2008, 2010, 2012 and 2013
- TDM gcc 4.5.2, 4.6.1 and 4.8.1
- Debian and Ubuntu linux (Ubuntu Jaunty and later)
- g++ 4.3, 4.4, 4.5, 4.6, 4.7, 4.8 and 4.9
- Fedora linux
- Fedora 13: g++ 4.4
- Fedora 14: g++ 4.5
- Fedora 15: g++ 4.6
- Fedora 16: g++ 4.6
- Fedora 17: g++ 4.7.2 or later
- Fedora 18: g++ 4.7.2 or later
- Fedora 19: g++ 4.8
- Fedora 20: g++ 4.8
- Fedora 21: g++ 4.9
- Intel x86 MacOSX Snow Leopard or later
- MacPorts g++ 4.3, 4.4, 4.5, 4.6, 4.7 and 4.8
Get your copy of Just::Thread
Purchase your copy and get started with the C++11 and C++14 thread library now.
Posted by Anthony Williams
[/ news /] permanent link
Tags: multithreading, concurrency, C++0x, C++11, C++14
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
Comments on the C++ Concurrency TS
Wednesday, 28 May 2014
It's been a while since I wrote any papers for the C++ committee, but I've written two for the committee mailing prior to the upcoming committee in Rapperswil:
- N4032: Comments on continuations and executors
- N4033: synchronized_value<T> for associating a mutex with a value
The first provides comments, and suggestions for improvements on the concurrency TS based on implementing continuations for Just::Thread V2, and executors for an unreleased internal build of Just::Thread.
The second proposes to standardize
the synchronized_value
class template from Just::Thread
Pro, with a couple of modifications.
Let me know if you have any comments.
Posted by Anthony Williams
[/ news /] permanent link
Tags: multithreading, concurrency, C++17
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
just::thread C++11 and C++14 Thread Library V2.0 released
Monday, 19 May 2014
I am pleased to announce that version 2.0 of just::thread, our C++11 and
C++14 Thread Library has just been released with new features and support for
new compilers.
This release includes the new std::shared_timed_mutex and
std::shared_lock from C++14, which allow for multiple readers to hold a shared lock
on a mutex or one writer to hold an exclusive lock.
Also included are extensions to the futures from the upcoming C++ Concurrency
Technical Specification in the form of
continuations. std::future<>
and std::shared_future<> now have an additional member
function "then()" which allows a further task to be scheduled when
the future becomes "ready". This allows for improved support for asynchronous
tasks.
There are also new functions: jss::when_any
and jss::when_all which encapsulate a set of futures into a single
future which becomes ready when either one or all of the provided futures
becomes ready. This can be used with continuations to schedule asynchronous
tasks to run when the prerequisites are ready.
Finally, a new lock wrapper jss::generic_lock_guard is provided. This is a
concrete type rather than a template, and will lock any type of mutex which
provides lock and unlock member functions.
This release also includes support for Microsoft Visual Studio 2013 and gcc 4.8.
Get your copy of Just::Thread
Purchase your copy and get started with the C++11 and C++14 thread library now.
Posted by Anthony Williams
[/ news /] permanent link
Tags: multithreading, concurrency, C++0x, C++11, C++14
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
ACCU 2014 - slides
Monday, 19 May 2014
This year's ACCU conference was at the Marriott hotel in Bristol again. As ever, the conference itself was enjoyable, educational and exhausting in equal measure, and it was good to meet up with people again.
This year, I was presenting on "The continuing future of C++ concurrency", with an overview of
the additions to the Standard C++ concurrency libraries proposed for the C++ concurrency TS and
C++17, including: continuations, executors, and parallel algorithms, as well as
std::shared_timed_mutex from C++14.
My presentation was well-attended, and there were lots of interesting questions.
The slides are available here.
Posted by Anthony Williams
[/ news /] permanent link
Tags: conferences, accu, cplusplus
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
ACCU 2013 and the C++ Standards Meeting
Monday, 06 May 2013
This year's ACCU conference was at a new venue: the Marriott hotel in Bristol. This is a bit closer to home for me than the previous venue in Oxford, which made the trip there and back more comfortable. As ever, the conference itself was enjoyable, educational and exhausting in equal measure.
This year was also BSI's turn to host the Spring ISO C++ committee meeting, which was conveniently arranged to be the week following ACCU, in the same hotel. Having not attended a meeting since the last time the committee met in the UK, I was glad to be able to attend this too.
ACCU 2013
As usual, with 5 tracks running simultaneously, it was hard to choose which sessions to attend. I stuck mostly to C++-centric, or general software development sessions, but there were also sessions on a wide range of other topics, including Ruby, Java, Scala, Git, C#, testing, management and culture, amongst others.
I was invited to contribute to Pete Goodliffe's Becoming a Better Programmer panel session, which was well attended and entertaining, as usual for Pete's sessions. My contribution on "doing things mindfully" seemed well-received, but wasn't the most popular — that honour went to Seb Rose, though Brian Marick called out Anna-Jayne Metcalfe's contribution on "If it ain't broke, do fix it" in the keynote the next morning.
My presentation on "C++11 in the Real World" was also well attended, with some good questions from the audience. A couple of people have asked me for my slides: they are available from the ACCU website.
ISO C++ committee meeting
This was a landmark meeting, for several reasons. Firstly, there were over 100 attendees, making it one of the most well-attended ISO C++ meetings ever. Secondly, this bumper attendee count was complemented by a bumper batch of proposals and position papers to process, which meant that all the working groups were pressed for time, and people met for extra sessions in the evenings to try and get through them all. Finally, the committee voted to publish a new "CD", starting the formal process leading to a C++14 standard.
The meeting was 6 days long, but I was only able to attend for the first 2 days. Unsurprisingly, I spent my time in the Concurrency group (SG1). We had a lot of papers to discuss, and some of the discussions were quite involved. Ultimately, not many papers were forwarded to the full committee, and only one paper other than the basic defect-report fixes was approved.
Lawrence Crowl's paper on Stream Mutexes
(N3535) was first
up. The problem this paper is trying to address is ensuring that data written to a stream from
multiple threads appears in a coherent order — though concurrent writes to
e.g. std::cout are guaranteed not to yield undefined behaviour, the output may be
interleaved in an arbitrary fashion. This got quite a bit of discussion over the course of the
week, and was eventually submitted as a much-modified paper for writing chunks to a stream in an
atomic fashion, which was voted down in full committee.
Herb Sutter's late paper on the behaviour of the destructor of std::future (N3630)
was up next. This is a highly conterversial topic, and yielded much discussion. The crux of the
matter is that as currently specified the destructor of std::future blocks if it came
from an invocation of std::async, the asynchronous function was run on a separate
thread (with the std::launch::async policy), and that thread has not yet
finished. This is highly desirable in many circumstances, but Herb argued that there are other
circumstances where it is less desirable, and this makes it hard to use std::future
in some types of program.
Much of the discussion focused on the potential for breaking existing code, and ways of
preventing this. The proposal eventually morphed into a new paper (N3637) which created 2 new
types of future: waiting_future
and shared_waiting_future. std::async would then be changed to return
a waiting_future instead of a future. Existing code that compiled
unchanged would then keep the existing behaviour; code that changed behaviour would fail to
compile. Though the change required to get the desired behaviour would not be extensive, the
feeling in the full committee was that this breakage would be too extensive, and the paper was
also voted down in full committee.
Herb's original paper also included a change to the destructor of std::thread, so
that the destructor of a joinable thread would call join() rather
than std::terminate(). This was put up for vote as N3636, but again was voted down in
full committee.
Like I said, there were lots of other papers up for discussion. Some were concrete proposals, whilst others were less complete, asking for feedback on the approach. Only one paper was approved for the C++14 time frame — whilst there was considerable interest in the idea behind some of the others, there was disagreement about the details, and nothing else was deemed ready. I look forward to seeing the revised versions of some of these proposals when they are ready, especially the executors, continuations and parallel algorithms papers.
The paper that did get approved was Howard Hinnant's paper on shared locking
(N3568), but even
that didn't go through unchanged. I have serious concerns about the upgrade_mutex
proposed in the original paper, and while I didn't manage to get my concerns across via email (this
was discussed after I left), there was not enough interest in including it in C++14. The approved
paper (N3659) therefore included only shared_mutex
and shared_lock, not upgrade_mutex, which is good. N3659 was also
approved by the vote in full committee, so will be part of C++14.
Wrap up
Having the conference and ISO meeting back-to-back was intense, but I thoroughly enjoyed attending both. C++14 looks set to be a significant improvement over C++11 — though the individual changes are minor, they offer quite a bit in terms of improved usability of the language and library. See the trip reports by Herb Sutter and Michael Wong (part 2, part 3) for more details on the accepted papers.
Posted by Anthony Williams
[/ news /] permanent link
Tags: accu, cplusplus, standards, iso
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
just::thread Pro: Actors Edition released
Tuesday, 23 April 2013
I am pleased to announce that the first release
of Just::Thread Pro is here. The Actors
Edition provides a framework for
creating actors that run on separate threads, and communicate via message passing, as well
as jss::synchronized_value
for synchronizing access to a single object
and jss::concurrent_map,
a hash map that is safe for concurrent access from multiple threads.
See the overview for more information, or read the full documentation.
Get your copy of Just::Thread Pro: Actors Edition
Purchase your copy and get started now.
Posted by Anthony Williams
[/ news /] permanent link
Tags: multithreading, concurrency, C++0x, C++11
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
ACCU 2013
Saturday, 06 April 2013
I'm presenting on "C++11 features and real-world code" at ACCU 2013 in Bristol on this coming Thursday, 11th April. Here's the abstract:
C++11 has many nifty features, but how do they actually impact developers at the code face? Which C++11 features offer the best bang for the buck?
In this session I'll look at a selection of C++11 language and library features that I've found of real practical benefit in application and library code, with examples of equivalent C++03 code.
The features covered will include the concurrency support (of course), lambdas, and "auto", amongst a variety of others.
Hope to see you there!
Posted by Anthony Williams
[/ news /] permanent link
Tags: conferences
Stumble It! | Submit to Reddit | Submit to DZone
If you liked this post, why not subscribe to the RSS feed or Follow me on Twitter? You can also subscribe to this blog by email using the form on the left.
Design and Content Copyright © 2005-2024 Just Software Solutions Ltd. All rights reserved. | Privacy Policy