Java Information Dynamics Toolkit (JIDT)

Block-wide primitives like cub::BlockRadixSort, cub::BlockLoad, and cub::BlockStore are used within CUDA kernels to perform collective operations across a thread block.

Specialization

These classes must be specialized by providing:

1. The data type being processed.
2. The number of threads per block.
3. The number of keys/items per thread.
4. (Implicitly) The targeted compilation architecture.

Memory Management

Once specialized, these classes expose an opaque TempStorage member type. To manage memory efficiently, thread blocks should use a union of these TempStorage types to statically allocate the required shared memory. This ensures that the total shared memory allocated is only as large as the largest required buffer among the used primitives.

Data Access Patterns

cub::BlockLoad and cub::BlockStore are designed to provide coalesced access to device memory. They use a striped access pattern (consecutive threads accessing consecutive items) and then transpose the keys into a blocked arrangement across threads.

#include <cub/cub.cuh>
 
// Block-sorting CUDA kernel
__global__ void BlockSortKernel(int *d_in, int *d_out)
{
     using namespace cub;

     // Specialize BlockRadixSort, BlockLoad, and BlockStore for 128 threads 
     // owning 16 integer items each
     typedef BlockRadixSort<int, 128, 16>                     BlockRadixSort;
     typedef BlockLoad<int, 128, 16, BLOCK_LOAD_TRANSPOSE>   BlockLoad;
     typedef BlockStore<int, 128, 16, BLOCK_STORE_TRANSPOSE> BlockStore;
 
     // Allocate shared memory using a union of TempStorage types
     __shared__ union {
         typename BlockRadixSort::TempStorage  sort;
         typename BlockLoad::TempStorage       load; 
         typename BlockStore::TempStorage      store; 
     } temp_storage; 

     int block_offset = blockIdx.x * (128 * 16);

     // 1. Load data from device memory to thread-local arrays
     int thread_keys[16];
     BlockLoad(temp_storage.load).Load(d_in + block_offset, thread_keys);
     __syncthreads();

     // 2. Collectively sort the keys within the block
     BlockRadixSort(temp_storage.sort).Sort(thread_keys);
     __syncthreads();

     // 3. Store the sorted segment back to device memory
     BlockStore(temp_storage.store).Store(d_out + block_offset, thread_keys);
}

To use functions defined in previous notebooks or external scripts, you have three main options:

1. Using the ipynb library: Install it via pip3 install ipynb. You can then import functions directly from notebooks using the syntax from ipynb.fs.full.NotebookName import function_name. Note that this executes the entire notebook upon import.
2. Using a dedicated script (Recommended): Save your functions in a Python script (e.g., simpleinfotheory.py) and import them using standard Python import statements. This is the preferred long-term solution for managing information theory functions.
3. Directly editing scripts: Manually paste your functions into a local .py file to maintain a library of reusable code.

pip3 install ipynb

# Option 1: Import from a notebook
from ipynb.fs.full.Module_1_notebook import entropy

# Option 2: Import from a local script (Recommended)
from simpleinfotheory import entropy

To perform the Scissors-Paper-Rock analysis, use the Matlab live script ScissorsPaperRockAnalysis.mlx. This script acts as a guide and orchestrates several supporting scripts to process player names, game data, and information-theoretic measures.

Core Analysis Scripts

• listPlayers.m: Extracts player names from the dataset.
• loadGamesForPlayer.m: Retrieves game data for a specific player.
• translateMove.m and translateResult.m: Converts encoded moves and results into human-readable text strings.
• computeEntropyForPlayer.m, computeConditionalEntropyForPlayer.m, and computeMutualInformationForPlayer.m: Calculate information-theoretic measures for an individual player.
• computeEntropyForAllPlayers.m, computeConditionalEntropyForAllPlayers.m, and computeMutualInformationForAllPlayers.m: Calculate information-theoretic measures for the entire player pool.

Manual Setup for External Analysis

If you wish to analyze the data outside of the provided live script, run setup.m first. This script initializes the necessary system paths required for the analysis scripts to function correctly.

% To initialize paths for analysis outside the live script:
setup;

To perform the Scissors-Paper-Rock analysis, you need to install pandas and re, and ensure you have the sprutils utility and your custom information theory scripts (e.g., simpleinfotheory.py) available in your Python path.

1. Download Data: Obtain the Scissors-Paper-Rock dataset and unzip it.
2. Configure Paths: Use sprutils.setDataPath() to point to your data files and sys.path.append() to include your information theory scripts.
3. Dependencies: The analysis requires numpy, scipy, and matplotlib.

import sprutils
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
import sys

# Set path for where your Scissors-Paper-Rock data files are stored
sprutils.setDataPath("../ScissorsPaperRock-SampleData")

# Set the path for your information theory scripts
sys.path.append('../../Module01-Entropy/PythonSimpleFunctions/completed/')
import simpleinfotheory