AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() # can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent Concurrency has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent 47] has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() # can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent Concurrency has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent 47] has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

what you can do when you have results: >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() # can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent Concurrency has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

what you can do when you have results: >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() # can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent Concurrency has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() the tasks won’t run long enough to block the worker from processing other waiting tasks. However, there’s a limit. Sending messages takes processing power and bandwidth. If your tasks are so short the overhead should reconsider your strategy. There is no universal answer here. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

what you can do when you have results: >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent 47] has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

AsyncResult: >>> result = add.delay(4, 4) >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None >>> result.get() # the tasks won’t run long enough to block the worker from processing other waiting tasks. However, there’s a limit. Sending messages takes processing power and bandwidth. If your tasks are so short the overhead should reconsider your strategy. There is no universal answer here. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory

what you can do when you have results: >>> result.ready() # returns True if the task has finished processing. False >>> result.result # task is not ready, so no return value yet. None 1.3. First steps with can process more tasks in parallel and the tasks won’t run long enough to block the worker from processing other waiting tasks. However, executing a task does have overhead. A message needs to be sent Concurrency has a whole section dedicated to the topic of task granularity. Data locality The worker processing the task should be as close to the data as possible. The best would be to have a copy in memory