http://groups.google.com/group/comp.programming.threads?hl=en
comp.programming.threads@googlegroups.com
Today's topics:
* Rs 20,000 INR at stake in CodeWarrior - 1 messages, 1 author
http://groups.google.com/group/comp.programming.threads/t/05b63fd13b282f21?hl=en
* strong atomic reference counting... - 3 messages, 2 authors
http://groups.google.com/group/comp.programming.threads/t/1b35d9cff58efb83?hl=en
* using proxy garbage collector in C# / Java... - 1 messages, 1 author
http://groups.google.com/group/comp.programming.threads/t/8c5014a275907b0e?hl=en
* Maximum Threads supported on Windows server 2003 - 1 messages, 1 author
http://groups.google.com/group/comp.programming.threads/t/2d900ff3e045fe10?hl=en
==============================================================================
TOPIC: Rs 20,000 INR at stake in CodeWarrior
http://groups.google.com/group/comp.programming.threads/t/05b63fd13b282f21?hl=en
==============================================================================
== 1 of 1 ==
Date: Tues, Feb 2 2010 1:24 pm
From: "!!ankit!!"
CodeFest & IEEE present to you CodeWarrior - Either Win or Die Coding!
It is a completely Online event with two cumulative rounds, testing
all aspects of your computer knowledge, be it programming, logical
reasoning, debugging or algorithm design.
There are prizes worth 20,000 INR & Codechef T-Shirts for the winners.
Problem Statements for First Round will be released on Feb 5, 1800 Hrs
(IST). Here is the problem break-up:
* 2 Puzzles
* 2 Algorithm Designing Problems
* 2 C/C++ Debugging Problems
* 1 Algorithm Intensive Programming Challenge
Sample Problems are also available. Sumission Deadline : Feb 14, 2100
Hrs (IST).
It is a team event with maximum of 2 members. So form your team now
and get ready for some baffling puzzles, buggy codes & bewildering
algorithms.
For further questions email us at codefest@itbhu.ac.in or contact the
following:
Shishir Mittal: +91-9936-180-121 shishir.mittal.cse06@itbhu.ac.in
Other Events at Codefest
* GumboRumble : Problem statements for Adobe sponsored 2 months
long application development competition with prizes worth 50,000
INR, have been released. Registrations and Submissions closes on Feb
24 2100 Hrs (IST).
* MathMania : An event with Challenging Mathematical Problems as
in Project Euler, Scheduled on Mar 13.
* Manthan : An algorithm intensive programming competition on the
lines of ACM-ICPC, to be hosted on Codechef. Scheduled on Mar 14.
* Perplexed! : C obscure Programming Competition, to get in-depth
knowledge of C. Scheduled on Mar 21.
Be free and Happy Coding!
Team Codefest.
Website: http://itbhu.ac.in/codefest
Twitter: http://twitter.com/c0defest
Blog: http://codefest.wordpress.com
==============================================================================
TOPIC: strong atomic reference counting...
http://groups.google.com/group/comp.programming.threads/t/1b35d9cff58efb83?hl=en
==============================================================================
== 1 of 3 ==
Date: Wed, Feb 3 2010 5:52 am
From: "Chris M. Thomasson"
"Chris M. Thomasson" <no@spam.invalid> wrote in message
news:L0g9n.1815$5n.101@newsfe23.iad...
> As you may already know, you can implement strongly thread-safe atomic
> reference counting using a PDR algorithm. The basic overall pattern is as
> follows:
> ____________________________________________________________________
[...]
> ____________________________________________________________________
>
>
>
>
> I wanted to try and eliminate that nasty CAS-loop in `acquire_strong()'
> which implements the "increment if not zero" logic. So, here is what I
> came up with:
> ____________________________________________________________________
[...]
> ____________________________________________________________________
>
> Instead of forcing the `acquire_strong()' function to never even try to
> increment a reference count that is zero, I simply inc/dec the count by 2,
> and when that goes to zero I _attempt_ to set it to 1. Therefore, the
> `acquire_strong()' function can "easily" detect reference counted objects
> that have already been deferred by checking to see if the count has the
> 0x1 bit set. I think I will model this in Relacy 2.2 using the following
> PDR implementation:
>
>
> http://cpt.pastebin.com/f71480694
>
>
> So far, I think that algorithm should work out fine.
Here is a model of my experimental reference counting algorithm in Relacy:
http://cpt.pastebin.com/f63893cd9
IMVHO, it's nice to be able to remove the CAS-loop from in the function that
acquires strong references. Anyway, what do you think of the technique?
Thanks!
:^)
== 2 of 3 ==
Date: Wed, Feb 3 2010 9:07 am
From: Marcel Müller
Chris M. Thomasson wrote:
> IMVHO, it's nice to be able to remove the CAS-loop from in the function
> that acquires strong references. Anyway, what do you think of the
> technique?
Once I completed to move my home I will have a look at this.
But I currently already have an implementation without a CAS loop and
with only one machine size word memory footprint. (The stolen bits
trick, but without the restriction in the number of active references.)
Unfortunately not very well tested so far.
Maybe I can improve this solution further with the ideas from your post.
Once it has successfully run for some time, I will post the code here.
Marcel
== 3 of 3 ==
Date: Wed, Feb 3 2010 9:43 am
From: "Chris M. Thomasson"
"Marcel Müller" <news.5.maazl@spamgourmet.com> wrote in message
news:4b69ad47$0$7626$9b4e6d93@newsspool1.arcor-online.net...
> Chris M. Thomasson wrote:
>> IMVHO, it's nice to be able to remove the CAS-loop from in the function
>> that acquires strong references. Anyway, what do you think of the
>> technique?
>
> Once I completed to move my home I will have a look at this.
>
> But I currently already have an implementation without a CAS loop and with
> only one machine size word memory footprint. (The stolen bits trick, but
> without the restriction in the number of active references.) Unfortunately
> not very well tested so far.
Now that's pretty interesting because the "stolen bits" are typically used
to actually represent the reference count itself. Therefore, I would very
much like to examine your algorithm Marcel.
> Maybe I can improve this solution further with the ideas from your post.
> Once it has successfully run for some time, I will post the code here.
I am looking forward to it; thanks.
BTW, have you ever played around with Dmitriy Vyukov's Relacy Race Detector?
http://groups.google.com/group/relacy
IMVHO, it's an essential tool to have!
==============================================================================
TOPIC: using proxy garbage collector in C# / Java...
http://groups.google.com/group/comp.programming.threads/t/8c5014a275907b0e?hl=en
==============================================================================
== 1 of 1 ==
Date: Wed, Feb 3 2010 8:15 am
From: "Chris M. Thomasson"
I know this sounds a bit odd, but I think there could be some fairly
beneficial usage cases for a proxy garbage collector algorithm in garbage
collected languages such as C# and Java. For instance, imagine trying to
implement a lock-free stack algorithm in C#. Okay, it's pretty easy because
the "native" GC solves the memory reclamation issue and ABA problem.
However, why put unneeded pressure on the native GC? Who knows how long the
GC is going take to actually let the program reuse nodes as it's a
completely non-deterministic process. Unfortunally, this behavior can end up
creating a sh%tload of nodes under periods of load and completely swamp the
GC which simply cannot be a good thing in any way, shape or form. I am
thinking that sending the nodes through a proxy garbage collector possibly
could significantly help things out. One reason is that the overall
algorithm I have in mind:
http://groups.google.com/group/comp.programming.threads/browse_frm/thread/a53f24de178b419f
is deterministic in the sense that objects can be reclaimed as soon as the
last thread releases a reference to it's previously acquired proxy collector
object. This means that nodes can most likely be reused much sooner than if
you let the "native" GC handle everything. That has to be a good thing
because it can help reduce the total number of nodes created thus taking
pressure off of the native GC.
Is this making sense to everybody? I would really enjoy hearing your
thoughts on the issue!
Thanks!
:^)
==============================================================================
TOPIC: Maximum Threads supported on Windows server 2003
http://groups.google.com/group/comp.programming.threads/t/2d900ff3e045fe10?hl=en
==============================================================================
== 1 of 1 ==
Date: Wed, Feb 3 2010 8:08 pm
From: Jonathan de Boyne Pollard
>
>
> We are developing a server application ,we have decided to adopt
> windows 2003/2008 server. We want to know the theoritical analysis as
> for as number of threads and process these server can support
> considering following paramerts
> 1. RAM
> 2. No of CPU
> 3. 32/64 bit processor
>
> Q1 What will be the maximum limit for threads (in the same process)
> considering above parameter ?
> Q2 What will be the maximum limit for total application at a time can
> run,considering above parameter ?
>
Q: How many copies of Manish can fit into this room?
R: How big is Manish? How big is the room? Will xe be standing stock
still or jigging around like a madman?
==============================================================================
You received this message because you are subscribed to the Google Groups "comp.programming.threads"
group.
To post to this group, visit http://groups.google.com/group/comp.programming.threads?hl=en
To unsubscribe from this group, send email to comp.programming.threads+unsubscribe@googlegroups.com
To change the way you get mail from this group, visit:
http://groups.google.com/group/comp.programming.threads/subscribe?hl=en
To report abuse, send email explaining the problem to abuse@googlegroups.com
==============================================================================
Google Groups: http://groups.google.com/?hl=en
No comments:
Post a Comment