TaskR/examples/fibonacci/python/fibonacci_mutex.py at ef7b1c9cb6529c5b943bf3a1f40e4395fac4128c · Algebraic-Programming/TaskR · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
"""
    Copyright 2025 Huawei Technologies Co., Ltd.

  Licensed under the Apache License, Version 2.0 (the "License")
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
"""


import time
import taskr

# Globally assigned variables
_runtime = None
_taskCounter = 0
_m = taskr.Mutex()

# Fibonacci without memoization to stress the tasking runtime
def fibonacci(currentTask, x):
  if x == 0: return 0
  if x == 1: return 1

  global _taskCounter
  global _runtime

  result1 = 0
  result2 = 0

  # Creating task functions
  def Fc1(task):
    nonlocal result1
    result1 = fibonacci(task, x - 1)

  def Fc2(task):
    nonlocal result2
    result2 = fibonacci(task, x - 2)

  fibFc1  = taskr.Function(Fc1)
  fibFc2  = taskr.Function(Fc2)

  # Creating two new tasks
  subTask1 = taskr.Task(_taskCounter, fibFc1)
  _m.lock(currentTask)
  _taskCounter += 1
  _m.unlock(currentTask)
  subTask2 = taskr.Task(_taskCounter, fibFc2)
  _m.lock(currentTask)
  _taskCounter += 1
  _m.unlock(currentTask)

  # Adding dependencies with the newly created tasks
  currentTask.addDependency(subTask1)
  currentTask.addDependency(subTask2)

  # Adding new tasks to TaskR
  _runtime.addTask(subTask1)
  _runtime.addTask(subTask2)

  # Suspending current task
  currentTask.suspend()

  return result1 + result2

def fibonacciDriver(initialValue, runtime):
  # Setting global variables
  global _taskCounter
  global _runtime
  _runtime = runtime

  # Storage for result
  result = 0

  # Creating task functions
  def Fc(task):
    nonlocal result
    result = fibonacci(task, initialValue)

  initialFc = taskr.Function(Fc)

  # Now creating tasks and their dependency graph
  initialTask = taskr.Task(_taskCounter, initialFc)
  _taskCounter += 1

  runtime.addTask(initialTask)

  # Initializing taskR
  runtime.initialize()

  # Running taskr
  startTime = time.time()
  runtime.run()
  runtime.wait()
  endTime = time.time()

  computeTime = endTime - startTime

  print(f"Running Time: {computeTime:.5f}s")
  print(f"Total Tasks: {_taskCounter}")

  # Finalizing taskR
  runtime.finalize()

  # Dereferencing this global instance to let runtime call his Destructor
  _runtime = None

  # Returning fibonacci value
  return result