added a few files

Author: adde9708

AVX2_and_FMA_test.py

@@ -1,25 +1,22 @@
 import ctypes
-from time import sleep
 
 
 def avx2_and_fma():
     for j in range(3):
         i = j * 64
         dest = i + 63 * i + 63 * i + 63 - i + 63 + 2
         src = dest * 2
-
         print(dest)
-        sleep(2)
         buf = ctypes.memset(src, dest, 0)
         print(buf)
-        sleep(2)
+
         break
 
     for j in range(15):
         i = j * 16
         dst = i + 15 * i + 15 + i + 1
         print(dst)
-        sleep(2)
+
         break
 
 

DMA_cell.py

@@ -1,11 +1,10 @@
-from typing import Union, Tuple, List
-from timeit import default_timer as timer
+from typing import List, Tuple, Union
 
 
 def dma_list(
     dst: int, ea_low: int, nbytes: int
 ) -> Union[None, Tuple[int, List[Tuple[int, int, int, int, int, int]]]]:
-    t1 = timer()
+
     result: List[Tuple[int, int, int, int, int, int]] = []
     tag_id: int = 0
     dma_list_elem: List[int] = [0, 31, 1, ea_low]
@@ -31,8 +30,7 @@ def dma_list(
 
         result.append((dma_list_elem[0], tag_id, dst, bits, all_32, stall))
         i += 1
-    t2 = timer()
-    print(t2 - t1)
+
     return list_size, result
 
 

cell_test.py

@@ -11,7 +11,6 @@ def vmult(
     varr = arr[:7] * array_size_by_four
     varr2 = arr2[:8] * array_size_by_four
     vout = tuple(map(mul, varr, varr2))
-    print(vout)
     return vout
 
 

checksum.py

@@ -0,0 +1,59 @@
+import time
+
+
+def checksum_hacker(arr: bytearray) -> int:
+    length: int = len(arr)
+    if length == 0:
+        return 0
+
+    sum_values: bytearray = bytearray([0] * 4)
+
+    sum_values = bytearray(
+        [
+            sum_values[j] + arr[z + i + j]
+            for z in range(0, length - 256 + 1, 256)
+            for i in range(0, min(256, length - z), 4)
+            for j in range(4)
+        ]
+    )
+
+    sum_values += bytearray(
+        [
+            arr[i]
+            for z in range(0, length - 256 + 1, 256)
+            for i in range(z + 256, min(length, z + 256))
+        ]
+    )
+
+    return sum(sum_values[:4]) ^ sum(sum_values[4:])
+
+
+def main():
+    # Benchmarking parameters
+    minSize = 1000  # Minimum size of data
+    maxSize = 10000  # Maximum size of data
+    step = 1000  # Step size for increasing data size
+
+    print("Data Size\tTime (ns)")
+
+    for dataSize in range(minSize, maxSize + 1, step):
+        # Generate random data of given size
+        data = bytearray(dataSize - 1000)
+
+        # Start the timer
+        start = time.perf_counter()
+
+        # Call the function to benchmark
+        checksum = checksum_hacker(data)
+        print(checksum)
+        # End the timer
+        end = time.perf_counter()
+
+        # Calculate elapsed time in nanoseconds
+        elapsedTime = end - start
+
+        print(f"{dataSize}\t\t{elapsedTime}")
+
+
+if __name__ == "__main__":
+    main()

fib.py

@@ -1,24 +1,23 @@
 from math import sqrt
 
-# O(1)
-
 
-def fib_const_time(n):
+# O(1)
+def fib_const_time(n: int):
     print("Fibonacci series")
-    phi = (1 + sqrt(5)) / 2
-    Fn = round((phi**n) / sqrt(5))
+    phi: float = (1 + sqrt(5)) / 2
+    Fn: int = round((phi**n) / sqrt(5))
     print(Fn)
 
 
 fib_const_time(10)
 
 
 # O(n)
-def fib(n):
+def fib(n: int):
     print("Fibonacci series")
-    phi = (1 + sqrt(5)) / 2
+    phi: float = (1 + sqrt(5)) / 2
     for i in range(n):
-        Fn = round((phi**i) / sqrt(5))
+        Fn: int = round((phi**i) / sqrt(5))
         print(Fn, end=" ")
     print()
 

help_queue.py

@@ -0,0 +1,63 @@
+from typing import Optional
+import threading
+
+
+# Node class
+class Node:
+    def __init__(self, value: int) -> None:
+        self.value: int = value
+        self.next: Optional[Node] = None
+        self.mutex: threading.Lock = threading.Lock()
+
+
+# Queue class
+class Queue:
+    def __init__(self) -> None:
+        dummy_value: int = 0
+        self.dummy_node: Node = Node(dummy_value)
+        self.head: Node = self.dummy_node
+        self.tail: Node = self.dummy_node
+
+
+# Function to try removing the front node
+def try_remove_front(queue: Queue, front: int) -> bool:
+    with queue.head.mutex:
+        head: Node = queue.head
+        if head.next is not None:
+            with head.next.mutex:
+                next_node: Node = head.next
+                if next_node.value == front:
+                    head.next = next_node.next
+                    del next_node
+                    return True
+    return False
+
+
+# Function to help finish enqueue
+def help_finish_enq(queue: Queue) -> None:
+    next_node: Optional[Node] = queue.tail.next
+    if next_node is not None and next_node == queue.tail:
+        with queue.tail.mutex:
+            with queue.head.mutex:
+                queue.tail.next = next_node
+                queue.tail = next_node
+
+
+# Function to enqueue a value
+def enqueue(queue: Queue, value: int) -> None:
+    node: Node = Node(value)
+    with queue.tail.mutex:
+        queue.tail.next = node
+        help_finish_enq(queue)
+
+
+# Main function
+if __name__ == "__main__":
+    q: Queue = Queue()
+    front_value: int = 10
+    enqueue(q, front_value)
+    result: bool = try_remove_front(q, front_value)
+    if result:
+        print(f"Successfully removed front node: {front_value}")
+    else:
+        print("Failed to remove front node")

ohm_enc.py

@@ -2,7 +2,7 @@
 from hmac import compare_digest
 from math import ceil, sqrt
 from secrets import SystemRandom, choice
-from typing import Tuple, Union, Optional
+from typing import Optional, Tuple, Union
 
 
 def ohm_enc(message: str) -> Tuple[float, int, bytes, int]:
@@ -60,6 +60,7 @@ def ohm_enc(message: str) -> Tuple[float, int, bytes, int]:
 def ohm_dec(
     key: float, random_key: int, iv: bytes, encrypted_message: int, message: str
 ) -> Optional[str]:
+
     # Calculate the number of bytes needed to represent the integer
     num_bytes = (encrypted_message.bit_length() + 7) // 8
 
@@ -78,19 +79,14 @@ def ohm_dec(
     message_hash = decrypted_bytes[:original_hash_length]
 
     # Compute the SHAKE256 hash of the original message
-    original_hash = shake_256(message.encode("utf-8")).digest(
-        original_hash_length
-    )
+    original_hash = shake_256(message.encode("utf-8")).digest(original_hash_length)
 
-    # Compare the message hash with the original hash
-    if compare_digest(message_hash, original_hash):
-        return message
-    else:
-        return None
+    return message if compare_digest(message_hash, original_hash) else None
 
 
 def main() -> None:
-    # Encrypt a message using ohm_enc
+
+    # Encrypt the message using ohm_enc
     message = "This is a secret message."
     key, random_key, iv, res = ohm_enc(message)
 

tic_tac_toe.py

@@ -1,20 +1,20 @@
-from typing import TypeVar
+from typing import Tuple, TypeVar
 
 T = TypeVar("T", int, int)
 
 
-def get_cell_position(cell_str: str) -> tuple[T, T]:
+def get_cell_position(cell_str: str) -> Tuple[T, T]:
     # Convert the letter part of the cell string to a column index
     column_index = ord(cell_str[0]) - ord("A")
 
     # Convert the digit part of the cell string to a row index
     row_index = int(cell_str[1]) - 1
 
     # Return the row and column indices as a tuple
-    return (row_index, column_index)
+    return row_index, column_index
 
 
-def tic_tac_toe() -> tuple[T, T]:
+def tic_tac_toe() -> Tuple[T, T]:
     board = [
         (" ", " ", "O"),
         ("X", " ", " "),
@@ -29,7 +29,7 @@ def tic_tac_toe() -> tuple[T, T]:
         print("There is an O in cell", cell_str)
     else:
         print("There is no X or O in cell", cell_str)
-    return (row, col)
+    return row, col
 
 
 tic_tac_toe()