Many ACE users are familiar with the ACE_Task::put(ACE_Message_Block*, ACE_Time_Value*=0) method that's used to pass some type of data (plain data, request object, etc.) into a task. It's a convenient way to pass a unit of work to some task for further processing. The put() method is used quite often for processing steps (as is often done in the Streams framework) as well as in the Active Object and Half-Sync/Half-Async patterns for handing work off to another thread.

The most common thing an application's implementation of put() does is to call ACE_Task::putq(ACE_Message_Block*, ACE_Time_Value*=0), essentially just queue the message block on the task's ACE_Message_Queue and return, enqueueing the data, usually so that a thread running in the context of the task can dequeue the item and perform whatever actions are needed.

Although enqueueing a block via putq() is a very common practice, there's no reason it has to be handled that way. The put() method is what's referred to as a variability point in the Task pattern. A variability point is a point at which you can vary the behavior of your class. In this case, you can implement your put() method to process the specified message block directly rather than queue it. Why would you do this? For example,

• you may not want the overhead of running a separate thread for simple processing
• you're using multiple processing threads and can afford to process even a lengthy work item without disturbing responsiveness
• you might want to experiment with and without queueing to measure performance both ways

You could even implement your put() method to sometimes queue the message block and other times process it directly depending on some criteria such as block size or system load. You can change it at will, and not affect callers of your task's put() method. Just be sure to adhere to the expected return value (-1 for error) and the caller's request timeout behavior, and you can implement any way that works for you.

C++NPv2 chapter 6 contains a lengthy background discussion of ACE_Task and some nice examples illustraing use of put(). If we can help clarify the various ways to use put(), or any other part of ACE, take advantage of our new service levels to get your questions answered today!

Riverace recently completed a survey of the ACE user community (thank you to all who responded!) to get feedback on what you like and don't like as well as what services would help more. One item that we learned was that there needs to be more flexibility in the ways users can get support from Riverace. The "one size fits all" plan we've had for a number of years just isn't flexible enough or accessible enough for everyone. Therefore, Riverace has expanded from the "one size fits all" support model to a matrix of different service levels and price models. There are three different levels of service available to better fit your support needs. In addition to our new service levels, we're also introducing size options in order to make Riverace's world-class expertise available to development groups of all sizes. Smaller groups will now have the ability to buy services per-developer, while larger groups still have the all-inclusive group-wide support option available.

The new per-developer pricing method is per developer on the project, not per contact that can call for support. All developers can call for support. This has been a point of confusion in the past, so please let us know if you have questions. As an additional budgeting aid for small groups, developer-based purchases can also select between an annual, semi-annual, or monthly support term.

The new service levels are tiered to allow you to get all the support you need without paying for things you don't need. These new service levels are:

1. Stream Level, for when you're cruising along without much pressure but want expertise to be available. Free access to all Riverace Fix Kits, and ask all the questions you want via our support customer-only web site! If you encounter a bug, we'll fix it in a future ACE version.
2. River Level, when there are a few rocks and deep pockets you could use some quick and sure help with. Free access to all Riverace Fix Kits, and all the questions and issues you can report. Plus, you can call us toll free (during normal support hours) to discuss your questions quickly. And, we'll get you any fixes you need patched into the supported ACE version you reported it against, and carry it forward to future ACE versions.
3. Whitewater Level, when you're working with current ACE development betas and you need expert guidance to successfully navigate the rough stuff. All the features in River Level, PLUS we'll do it all for the regularly supported ACE versions AND the current beta. Whitewater Level also includes up to 10 hours per year of expert development assistance for adding new or enhanced features to the ACE development stream.

So, you have new service options, price options, and payment options. You can even change between service levels if your needs change. We'll automatically renew your selected term and you can cancel your service at the end of its current term (month, half year, or year). In exchange for selecting a group-wide year term (or, without a group, when there are 5 or more developers on a year term) we commit to keep ACE supported on your platform(s) for the year. We help each other. And that's what Riverace is all about - helping you succeed.