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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
<h1>How fast is a C++ extension</h1>
<p>
Native extensions are fast. But how fast are they? We can demonstrate this
with a very simple extension: bubblesort.
</p>
<p>
Bubblesort is a very inefficient sorting algorithm that is never used in
real world software - but that is often used in universities to demonstrate
algorithms. We will show you an implementation of this algorithm in PHP
and in C++ - and see how much faster the C++ code is.
</p>
<p>
<pre class="language-php"><code>
<?php
/**
* Bubblesort function in PHP
*
* This function takes an unsorted array as input, sorts it, and returns
* the output. It only uses normal PHP operation, and does not rely on
* any builtin PHP functions or on functions from extensions
*
* @param array An unsorted array of integers
* @return array A sorted array
*/
function scripted_bubblesort(array $input)
{
// number of elements in the array
$count = count($input);
// loop through the array
for ($i = 0; $i < $count; $i++)
{
// loop through the elements that were already processed
for ($j = 1; $j < $count - $i; $j++)
{
// move on if smaller
if ($input[$j-1] <= $input[$j]) continue;
// swap elements
$temp = $input[$j];
$input[$j] = $input[$j-1];
$input[$j-1] = $temp;
}
}
}
?>
</code></pre>
</p>
<p>
And exactly the same algorithm in C++:
</p>
<p>
<pre class="language-c++"><code>
#include <phpcpp.h>
/**
* Bubblesort function in C++
*
* This function takes an unsorted array as input, sorts it, and returns
* the output. Notice that we have not really done our best to make the
* implementation of this function as efficient as possible - we use stl
* containers for example - it is simple looking plain C++ function with
* a lot of room for improvements.
*
* @param array An unsorted array of integers
* @return array A sorted array
*/
Php::Value native_bubblesort(Php::Parameters ¶ms)
{
// there is one input array, cast the PHP variable to a vector of ints
std::vector<int> input = params[0];
// loop through the array
for (size_t i = 0; i < input.size(); i++)
{
// loop through the elements that were already processed
for (size_t j = 1; j < input.size() - i; j++)
{
// move on if smaller
if (input[j-1] <= input[j]) continue;
// swap elements
temp = input[j];
input[j] = input[j-1];
input[j-1] = temp;
}
}
}
/**
* Switch to C context, because the Zend-engine calls the get_module() method
* in C context, and not in C++ context
*/
extern "C" {
/**
* When a PHP extension starts up, the Zend engine calls the get_module()
* function to find out which functions and classes are offered by the
* extension
*
* @return void* pointer to memory address holding the extension information
*/
PHPCPP_EXPORT void *get_module()
{
// create an instance of the Php::Extension class
static Php::Extension extension("bubblesort", "1.0");
// add the bubblesort function to the extension, we also tell the
// extension that the function receives one parameter by value, and
// that that parameter must be an array
extension.add("native_bubblesort", native_bubblesort, {
ByVal("input", Php::Type::Array)
});
// return the extension
return extension;
}
}
</code></pre>
</p>
<p>
You may be surprised how simple the C++ function looks. It is almost identical
to the PHP code. That's true indeed, writing native extensions with PHP-CPP
is simple, and you can easily port your PHP functions to C++.
</p>
<p>
You also see an additional get_module() function in the extension call. This
is the startup function that is called by the Zend engine when PHP starts up.
It is supposed to return information to the Zend engine about the extension,
so that the "native_bubblesort" function is accessible for PHP scripts.
</p>
|