PHP Classes

PHP Threads Class: Run multiple tasks in parallel using HTTP requests

Recommend this page to a friend!
     
  Info   Example   View files Files   Install with Composer Install with Composer   Download Download   Reputation   Support forum   Blog    
Ratings Unique User Downloads Download Rankings
Not enough user ratingsTotal: 438 All time: 6,268 This week: 80Up
Version License PHP version Categories
cthreads 1.0Freeware5.0PHP 5, Language
Description 

Author

Amilton Junior

This class can run multiple tasks in parallel using HTTP requests.

It can send HTTP requests to the same Web server and the same script that is currently running.

The class can pass the name of a function to execute in the child thread, as well additional parameters to pass to it.

Multiple threads may be started in parallel. The class can return the results each thread given the thread identifier.

Picture of Amilton Junior
Name: Amilton Junior <contact>
Classes: 1 package by
Country: Brazil Brazil

 

Example

<?php
/*
    File: matrix.php
    Description: Matrix multiplication example using CThreads library.
    Usage: Call from the browser this file.
    URL Parameters:
        threads - (int) number of threads (2 default)
        size - (int) size of the matrix (size x size) (4 default)
        print - (int) 1 to print out, 0 to not
   
    Author: Amilton de Camargo Jr. <amilton@dicasemgeral.com>
   
    Copyright (cc) 2014 - Amilton de Camargo Jr. <amilton@dicasemgeral.com>
*/

// Include CThreads library
require_once('CThreads.php');

///////// FUNCTIONS //////////

// Function that generates a matrix
// Arguments:
// (int) $size - Size of the matrix (size x size)
// (int) $rand_from - First number range
// (int) $rand_to - Last number range
// Return:
// (array) $matrix - Generated matrix
function GenerateMatrix($size=0, $rand_from=1, $rand_to=2)
{
    // If it got an invalid size
    if ( $size < 2 )
        return array();
   
    $matrix = array();
   
    // Generate the matrix
    for ( $i=0; $i<$size; $i++ )
        for ( $j=0; $j<$size; $j++ )
            $matrix[$i][$j] = ($rand_from == $rand_to) ? $rand_from : mt_rand($rand_from, $rand_to);
   
    return $matrix;
}

// Function that prints a matrix
// Arguments:
// (array) $matrix - Matrix to be printed
// (int) $size - Matrix size
// Return:
// (void)
function PrintMatrix($matrix=array(), $size=0)
{
    // If invalid arguments
    if ( !is_array($matrix) || $size < 0 )
        return;
   
    // Print the matrix
    for ( $i=0; $i<$size; $i++ )
    {
        for ( $j=0; $j<$size; $j++ )
            echo $matrix[$i][$j] . '&nbsp;&nbsp;&nbsp;';
       
        echo '<br>';
    }
}

// Function to calculate a piece of a matrix
// Arguments:
// (array/int/float/String) $args - Arguments for the function
// Return:
// (array) $ret - Array with startpoint, endpoint, and result matrix
function Multiply($args)
{
    // If not a valid argument
    if ( !is_array($args) )
        return;
   
    // Get the arguments
    $t_number = $args['t_number']; // Thread ID
    $size = $args['size']; // Matrix size
    $threads = $args['threads']; // Number of threads
    $first = $args['first']; // First matrix
    $second = $args['second']; // Second matrix
    $result = array(); // Result matrix (local)
   
    if ( $threads > 1 )
    {
        // Calculate the thread's boundaries
        $rows = (int) ($size / $threads);
        $start = (int) ($rows * $t_number);
        $end = (int) ($start + $rows);
        $dif = (int) ($size - ( $threads * $rows ));
       
        // If it is the first thread and the matrix size is odd
        if ( $t_number == 0 && $size % 2 != 0 && $dif > 0 )
            $end += $dif;
    }
    else
    {
        $start = 0;
        $end = $size;
    }
   
    // Perform the calculation
    for ( $i=$start; $i<$end; $i++ )
        for( $j=0; $j<$size; $j++ )
            for( $k=0; $k<$size; $k++ )
                $result[$i][$j] += $first[$i][$k] * $second[$k][$j]; // Save the result to the resultant matrix
   
    // Return the values
    $ret = array();
    $ret['start'] = $start;
    $ret['end'] = $end;
    $ret['result'] = $result;
   
    return $ret;
}

// Get the result form all calculations and make the final matrix
// Arguments:
// (array) $results - Results from threads
// (int) $threads - Number of threads
// (int) $size - Matrix size
// Return:
// (array) $result - Result matrix from multiplication
function FinalResult($results=array(), $threads=0, $size=0)
{
    $result = array();
   
    for ( $t=0; $t<$threads; $t++ )
    {
        $start = $results[$t]['start'];
        $end = $results[$t]['end'];
        $res = $results[$t]['result'];
       
        for ( $i=$start; $i<$end; $i++ )
            for ( $j=0; $j<$size; $j++ )
                $result[$i][$j] = $res[$i][$j];
    }
   
    return $result;
}

//////////// MAIN PROGRAM /////////////

$threads = (isset($_GET['threads'])) ? (int) $_GET['threads'] : 2; // Number of threads
$m_size = (isset($_GET['size'])) ? (int) $_GET['size'] : 4; // Matrix size
$matrix1 = GenerateMatrix($m_size); // First matrix
$matrix2 = GenerateMatrix($m_size); // Second matrix
$result = array(); // Result of the multiplication
$thread_handle = new CThreads(); // Thread handles object
$printOut = (isset($_GET['print'])) ? (int) $_GET['print'] : true; // Boolean variable whether to print or not

// Print tha matrices
if ( $printOut )
{
    echo '<b>Matrix Multiplication</b><br><br>';
    echo '<table><tr><td>';
    echo 'Matrix 1:<br><br>';
    PrintMatrix($matrix1, $m_size);
    echo '</td><td width="50">&nbsp;</td><td>';
    echo 'Matrix 2:<br><br>';
    PrintMatrix($matrix2, $m_size);
    echo '</td></tr></table>';
}

echo "<br>> Using {$threads} thread(s) to calculate...<br>";

// Beginning timestamp
$parallel_start_time = microtime(true);

if ( $threads == 1 )
{
    // Set the arguments
    $args = array(); // Initialize the variable
    $args['t_number'] = 0; // Thread ID
    $args['size'] = $m_size; // Matrix size
    $args['threads'] = 1; // Number of threads
    $args['first'] = $matrix1; // First matrix
    $args['second'] = $matrix2; // Second matrix
   
    // Perform the calculation and get the result
    $threads_results[0] = Multiply($args);
}
else
{
    // Create the threads
    for ( $i=0; $i<$threads; $i++ )
    {
        // Set the arguments
        $args = array(); // Initialize the variable
        $args['t_number'] = $i; // Thread ID
        $args['size'] = $m_size; // Matrix size
        $args['threads'] = $threads; // Number of threads
        $args['first'] = $matrix1; // First matrix
        $args['second'] = $matrix2; // Second matrix
       
        // Create the thread and set the function to call and its arguments
        $thread_handle->AddThread('Multiply', $args, true);
    }
   
    // Run all threads
    $thread_handle->Run();
   
    // Get the result from all threads
    $threads_results = $thread_handle->GetResults();
}

// End timestamp
$parallel_end_time = microtime(true);

// Get the final result
$result = FinalResult($threads_results, $threads, $m_size);

// Print out the result
if ( $printOut )
{
    echo '<br>Result:<br><br>';
    PrintMatrix($result, $m_size);
}

echo '<br>Parallel part done in '.round($parallel_end_time-$parallel_start_time, 3).' seconds<br>';

?>

  Files folder image Files (2)  
File Role Description
Plain text file CThreads.php Class Main class
Accessible without login Plain text file matrix.php Example Example of usage

The PHP Classes site has supported package installation using the Composer tool since 2013, as you may verify by reading this instructions page.
Install with Composer Install with Composer
Downloadcthreads-2014-10-24.zip 4KB
Downloadcthreads-2014-10-24.tar.gz 4KB
Install with ComposerInstall with Composer
 Version Control Unique User Downloads Download Rankings  
 0%
Total:438
This week:0
All time:6,268
This week:80Up

  Applications that use this package  
No pages of applications that use this class were specified.

Add link image If you know an application of this package, send a message to the author to add a link here.