refactor: cleanup old files and update README.md

Author: domferr

README.md

@@ -3,68 +3,55 @@
 ### Farm
 
 ```py
-from fastflow_subint_module import FFFarm
+from fastflow_module import FFFarm, GO_ON
+import sys
+
+class source():
+ def __init__(self):
+ self.counter = 1
 
-# define an emitter
-class emitter():
  def svc(self, *args):
- data = do_some_work()
- return data # data to send to workers
+ # args are sent by the previous stage 
+ # or is an empty tuple if it is the first stage
+ if self.counter == 12:
+ return
+ self.counter += 1
 
- def svc_end(self):
- do_some_work() # do some work when the emitter ends
+ return list(['source'])
 
 class worker():
- def svc(self, *args): # args are sent by the emitter
- # perform some work
- data = busy_work(args)
-
- return data # data to send to collector
-
- def svc_end(self):
- do_some_work() # do some work when the worker ends
-
-class collector():
- def svc_init(self):
- do_some_work() # do some work when the collector starts
- return 0 # 0 for success, error otherwise
+ def __init__(self, id):
+ self.id = id
 
- def svc(self, *args): # args are sent by the workers
- # perform some work
- busy_work(args)
-
- return 0
+ def svc(self, lis: list):
+ lis.append(self.id)
+ return lis
 
+class sink(): 
+ def svc(self, lis: list):
+ print(lis)
+ return GO_ON
 
 # create a farm, pass True or False if you want to use subinterpreters or not
-farm = FFFarm(True)
-
-# create and add emitter
-em = emitter()
-farm.add_emitter(em)
-
-# create and add collector
-coll = collector()
-farm.add_collector(coll)
-
-# create 4 workers and put them into a list
+farm = FFFarm(False)
+sourcenode = source()
+sinknode = sink()
 w_lis = []
-for i in range(4):
+for i in range(3):
  w = worker(f"{i+1}")
  w_lis.append(w)
-# add the list of workers to the farm
+farm.add_emitter(sourcenode)
 farm.add_workers(w_lis)
-
+farm.add_collector(sinknode)
 # finally run the farm. Blocking call: will resume when the farm ends
 farm.run_and_wait_end()
-# print how many milliseconds the farm took
-print(f"farm done in {farm.ffTime()}ms")
+
 ```
 
 ### Pipeline
 
 ```py
-from fastflow_subint_module import FFPipeline
+from fastflow_module import FFPipeline, GO_ON
 
 # define a stage
 class stage():
@@ -85,7 +72,7 @@ class sinkstage():
 
  def svc(self, *args): # args are sent by the previous stage
  data = do_some_work()
- return 0
+ return GO_ON
 
 # create a pipeline, pass True or False if you want to use subinterpreters or not
 pipe = FFPipeline(use_subinterpreters)
@@ -105,24 +92,5 @@ pipe.add_stage(sink)
 # finally run the pipeline. Blocking call: will resume when the pipeline ends
 pipe.run_and_wait_end()
 # print how many milliseconds the pipeline took
-print(f"farm done in {farm.pipeline()}ms")
-```
-
-## Open questions
-- How to handle multi input/output nodes? The function ff_send_out(...) is not a member of the node class. A possible solution:
-```
-class worker():
- def svc(self, *args): # args are sent by the emitter
- # perform some work
- data = busy_work(args)
- fastflow.ff_send_out(data, 1) # <----- call ff_send_out
- return # the underline ff_node should continue instead of stopping
-
- def svc_end(self):
- do_some_work() # do some work when the worker ends
-```
-- How to handle renaming of imported modules when recreating the environment in subinterpreters? For example `import numpy as np` would cause the statement `import np` when recreating the environment.
-- Can we use shared memory instead of pipes?
-- Why calling `svc` inside subinterpreters is slower than calling it inside processes (including the time needed to send through pipe + recv ack + recv response + send ack)...?
-- Memory leaks...
-- Workers are added to the farm at the same time. The environment is serialized for each worker, but it may be just serialized once and shared accross all the workers. However it is not easy: if done during svc_init, how can we share the env accross all the workers and how we choose which worker does the serialization?
+print(f"pipeline done in {farm.ffTime()}ms")
+```

benchmark/busy_wait/busy_wait.pyx.old

@@ -1,4 +1,4 @@
-from fastflow_module import FFFarm
+from fastflow_module import FFFarm, GO_ON
 import argparse
 import sys
 import busy_wait
@@ -33,52 +33,25 @@ def __init__(self, data_sample, n_tasks):
  self.n_tasks = n_tasks
  self.data_sample = data_sample
 
- def svc_init(self):
- print('[emitter] svc_init was called')
- return 0
-
  def svc(self, *args):
- print(f'[emitter] svc, remaining tasks = {self.n_tasks}')
  if self.n_tasks == 0:
- return None
+ return
  self.n_tasks -= 1
 
  return DummyData(self.data_sample)
 
- def svc_end(self):
- print(f'[emitter] svc_end was called')
-
 class worker():
  def __init__(self, ms, id):
  self.ms = ms
  self.id = id
 
- def svc_init(self):
- print(f'[{self.id} | worker] svc_init was called')
- return 0
-
- def svc(self, *args):
- print(f'[{self.id} | worker] svc')
- 
+ def svc(self, *args): 
  busy_wait.wait(self.ms)
-
  return args
 
- def svc_end(self):
- print(f'[{self.id} | worker] svc_end was called')
-
-class collector():
- def svc_init(self):
- print('[collector] svc_init was called')
- return 0
- 
+class collector(): 
  def svc(self, *args):
- print('[collector] svc')
-
- return args
-
- def svc_end(self):
- print(f'[collector] svc_end was called')
+ return GO_ON
 
 def build_farm(n_tasks, task_ms, nworkers, data_sample, use_subinterpreters = False, use_main_thread = False):
  farm = FFFarm(use_subinterpreters)