Jared Fields UNIcodeX

## LICENSE


MIT License

Copyright (c) 2021 Daniel Ethridge

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights

## threadSafeFuture.nim
# threadSafeFuture.nim
# Jens Alfke, 30 June 2020

import asyncdispatch, deques, locks, sugar, threadpool

## Utilities for mixing async/await with threads.
##
## ``threadSafe()`` takes a Future and returns a new Future that can be completed on any thread.
## The original Future's callback will still be invoked on its original thread, and ``await``
## works normally.

## workq.nim
# nim c -r --threads:on --gc:orc

import cpuinfo, os, random, locks, deques

type
  WorkReq = ref object
    id: int

  WorkRes = ref object
    id: int

## floatingCSSButtons.html
<html>
  <style>
    .floating-button {
      z-index: 1000;
      position: fixed;
      border-radius: 33px;
      padding: 20px;
      text-decoration: none;
    }


## stacklessGlobalMutate.py
import stackless

class T:
  metric = 0

instance_T = T


def increment_T_metric(instance):
  instance.metric += 1

## xmonader-sequential_vs_async_vs_parallel-example.nim
# This came from https://github.com/xmonader/nim-linkcheck
# I just added the parallel example to the code and slightly modified the output formatting.
# My tests yielded the following numbers
# Sequential : 6.77 seconds
# Async      : 0.27 seconds (25.07x faster | 3.988% time of sequential | 96.01 % faster)
# Parallel   : 0.34 seconds (19.91x faster | 5.022% time of sequential | 94.98 % faster)

import os, httpclient
import strutils
import times

## parallelProcessingNoPointerThreadanalysisOn.nim
import locks, threadpool, strutils
# compile with:
# nim c -r --threads:on -d:danger --gc:arc
{.experimental: "parallel".}

var
  lock: Lock
  a: seq[string]

initLock lock

## parallelProcessingGlobalVarWithExplicitPointerThreadanalysisOn.nim
import locks, threadpool, strutils
# compile with:
# nim c -r --threads:on -d:danger --gc:arc
{.experimental: "parallel".}

var
  lock: Lock
  a: array[20, string]

initLock lock

## parallelProcessingGlobalVarWithImplicitPointer.nim
import locks, threadpool, strutils
# compile with:
# nim c -r --threads:on -d:danger --threadanalysis:off --gc:arc
{.experimental: "parallel".}

var
  lock: Lock
  a: array[20, string]

initLock lock

## parallelProcessingGlobalVarNoPointers.nim
import locks, threadpool, strutils
{.experimental: "parallel".}

var
  lock: Lock
  a {.guard: lock.}: array[20, string]

initLock lock

proc process(s: string): string =



	MIT License

	Copyright (c) 2021 Daniel Ethridge

	Permission is hereby granted, free of charge, to any person obtaining a copy
	of this software and associated documentation files (the "Software"), to deal
	in the Software without restriction, including without limitation the rights
	# threadSafeFuture.nim
	# Jens Alfke, 30 June 2020

	import asyncdispatch, deques, locks, sugar, threadpool

	## Utilities for mixing async/await with threads.
	##
	## ``threadSafe()`` takes a Future and returns a new Future that can be completed on any thread.
	## The original Future's callback will still be invoked on its original thread, and ``await``
	## works normally.
	# nim c -r --threads:on --gc:orc

	import cpuinfo, os, random, locks, deques

	type
	WorkReq = ref object
	id: int

	WorkRes = ref object
	id: int
	<html>
	<style>
	.floating-button {
	z-index: 1000;
	position: fixed;
	border-radius: 33px;
	padding: 20px;
	text-decoration: none;
	}
	import stackless

	class T:
	metric = 0

	instance_T = T


	def increment_T_metric(instance):
	instance.metric += 1
	# This came from https://github.com/xmonader/nim-linkcheck
	# I just added the parallel example to the code and slightly modified the output formatting.
	# My tests yielded the following numbers
	# Sequential : 6.77 seconds
	# Async : 0.27 seconds (25.07x faster \| 3.988% time of sequential \| 96.01 % faster)
	# Parallel : 0.34 seconds (19.91x faster \| 5.022% time of sequential \| 94.98 % faster)

	import os, httpclient
	import strutils
	import times
	import locks, threadpool, strutils
	# compile with:
	# nim c -r --threads:on -d:danger --gc:arc
	{.experimental: "parallel".}

	var
	lock: Lock
	a: seq[string]

	initLock lock
	import locks, threadpool, strutils
	# compile with:
	# nim c -r --threads:on -d:danger --threadanalysis:off --gc:arc
	{.experimental: "parallel".}

	var
	lock: Lock
	a: array[20, string]

	initLock lock