pool

We have a suspect application leaving a connection open. Just wondering on the debugging tools for this, as to whether anyone has any good tools for isolating this, commercial or otherwise. I've Googled but only seem to bring up articles that describe the problem - not the steps for a solution. This is the best article I've seen so far. - Others welcome. Anyone have any products that isolate the problematic code? Profilers which perform this sort of thing, or any other advice to add? You can always check the Activity Monitor on SQL Server to see if the application is keeping the connection

The code below works perfectly on Unix but generates a multiprocessing.TimeoutError on Windows 7 (both OS use python 2.7). Any idea why? Thanks. from multiprocessing import Pool def increment(x): return x + 1 def decrement(x): return x - 1 pool = Pool(processes=2) res1 = pool.map_async(increment, range(10)) res2 = pool.map_async(decrement, range(10)) print res1.get(timeout=1) print res2.get(timeout=1) You need to put your actual program logic in side a if __name__ == '__main__': block. On Unixy systems, Python forks, producing multiple processes to work from. Windows doesn't have fork. Python

my Message Driven Bean executes highly intensive operations so I would like to restrict it's pool size or my server would have been overloaded. I have tried this ( code ) but it doesn't work, it's pool is still 32 ( empirically tested, time to time I restart a server so there are no pooled instances ). @MessageDriven( mappedName = "jms/TestTopic", activationConfig = { @ActivationConfigProperty( propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge" ), @ActivationConfigProperty( propertyName = "destinationType", propertyValue = "javax.jms.Topic" ), @ActivationConfigProperty(

I have a Python program that takes around 10 minutes to execute. So I use Pool from multiprocessing to speed things up: from multiprocessing import Pool p = Pool(processes = 6) # I have an 8 thread processor results = p.map( function, argument_list ) # distributes work over 6 processes! It runs much quicker, just from that. God bless Python! And so I thought that would be it. However I've noticed that each time I do this, the processes and their considerably sized state remain, even when p has gone out of scope; effectively, I've created a memory leak. The processes show up in my System

I am experiencing very strange issues while working with the data inside my function that gets called by pool.map. For example, the following code works as expected... import csv import multiprocessing import itertools from collections import deque cur_best = 0 d_sol = deque(maxlen=9) d_names = deque(maxlen=9) **import CSV Data1** def calculate(vals): #global cur_best sol = sum(int(x[2]) for x in vals) names = [x[0] for x in vals] print(", ".join(names) + " = " + str(sol)) def process(): pool = multiprocessing.Pool(processes=4) prod = itertools.product(([x[2], x[4], x[10]] for x in Data1))

I want to use at least 9 image & they will be use via pool. But i can use only one texture for a Pool Class & can't use rest other. My code: Like: public class BubblePool extends GenericPool<Bubble> { public static BubblePool instance; private PixelPerfectTiledTextureRegion aITiledTextureRegion; public BubblePool(PixelPerfectTiledTextureRegion aTextureRegion) { if (aTextureRegion == null) { throw new IllegalArgumentException( "The Texture Region must not be null"); } this.aITiledTextureRegion = aTextureRegion.deepCopy(); instance = this; } public static BubblePool sharedBubblePool() { // if

I have a simple python multiprocessing script that sets up a pool of workers that attempt to append work-output to a Manager list. The script has 3 call stacks: - main calls f1 that spawns several worker processes that call another function g1. When one attempts to debug the script (incidentally on Windows 7/64 bit/VS 2010/PyTools) the script runs into a nested process creation loop, spawning an endless number of processes. Can anyone determine why? I'm sure I am missing something very simple. Here's the problematic code: - import multiprocessing import logging manager = multiprocessing