Benchmark: Bitwise vs Boolean data handling

Script Preparation code:

function CompletedCourses() {
    

    this.init = function() {
        this._state = new Array(COURSES.length).fill(false);
    }

    this.completeCourse = function(index) {
        this._state[index] = true;
    }


    this.getCompletedCourses = function() {
        const completedCourses = COURSES.filter((course, index) => this._state[index]);
        return completedCourses;
    }	
  this.init();
  	return this;
}

function CompletedCoursesBits() {
    
	
    
    this.initBits = function() {
        // using bits
        this._status = 0;
    }

    this.completeCourseBit = function(index) {
        this._status = this._status | 1 << index;
    }

    this.getCompletedCoursesByBits = function() {
        const completedCourseWithBits = COURSES.filter((course, index) => (this._status & 1 << index));
        return completedCourseWithBits;
    }
    this.initBits();
  return this;
}

function Student(name, completedCourses) {
    this.name = name;
    this.courses = completedCourses;
}

var COURSES = [
    'English',
    'Chemistry',
    'Physics',
    'Literature',
    'Arts',
    'Algabra',
    'Infi',
    'Algorithms',
    'DataStructures',
    'Complexity'
];

var n = 10000;

​x
 
function CompletedCourses() {    ​    this.init = function() {        this._state = new Array(COURSES.length).fill(false);    }​    this.completeCourse = function(index) {        this._state[index] = true;    }​​    this.getCompletedCourses = function() {        const completedCourses = COURSES.filter((course, index) => this._state[index]);        return completedCourses;    }     this.init();    return this;}​function CompletedCoursesBits() {                this.initBits = function() {        // using bits        this._status = 0;    }​    this.completeCourseBit = function(index) {        this._status = this._status | 1 << index;    }​    this.getCompletedCoursesByBits = function() {        const completedCourseWithBits = COURSES.filter((course, index) => (this._status & 1 << index));        return completedCourseWithBits;    }    this.initBits();  return this;}​function Student(name, completedCourses) {    this.name = name;    this.courses = completedCourses;}​var COURSES = [    'English',    'Chemistry',    'Physics',    'Literature',    'Arts',    'Algabra',    'Infi',    'Algorithms',    'DataStructures',    'Complexity'];​var n = 10000;

Tests:

Bitwise

function startBits() {
  // create
  const students = [];
  for (let i = 0; i < n; i++) {
    students.push(new Student('Mike', new CompletedCoursesBits()));
  }
  
  for (let i = 0; i < n; i++) {
    const student = students[i];
    COURSES.forEach((course, index) => index & 1 ? student.courses.completeCourseBit(index) : '')
  }
  
  // log
  const list = [];
  
  for (let i = 0; i < n; i++) {
    const student = students[i];
    list.push(student.courses.getCompletedCoursesByBits());
  }
}
startBits();

 
function startBits() {  // create  const students = [];  for (let i = 0; i < n; i++) {    students.push(new Student('Mike', new CompletedCoursesBits()));  }    for (let i = 0; i < n; i++) {    const student = students[i];    COURSES.forEach((course, index) => index & 1 ? student.courses.completeCourseBit(index) : '')  }    // log  const list = [];    for (let i = 0; i < n; i++) {    const student = students[i];    list.push(student.courses.getCompletedCoursesByBits());  }}startBits();

Boolean

function start(){
  // create
  const students = [];
  for (let i = 0; i < n; i++) {
    students.push(new Student('Mike', new CompletedCourses()));
  }
  
  // populate
  for (let i = 0; i < n; i++) {
    const student = students[i];
    COURSES.forEach((course, index) => index & 1 ? student.courses.completeCourse(index) : '')
  }
  
  // log
  const list = [];
  for (let i = 0; i < n; i++) {
    const student = students[i];
    list.push(student.courses.getCompletedCourses());
  }
}
start();

 
function start(){  // create  const students = [];  for (let i = 0; i < n; i++) {    students.push(new Student('Mike', new CompletedCourses()));  }    // populate  for (let i = 0; i < n; i++) {    const student = students[i];    COURSES.forEach((course, index) => index & 1 ? student.courses.completeCourse(index) : '')  }    // log  const list = [];  for (let i = 0; i < n; i++) {    const student = students[i];    list.push(student.courses.getCompletedCourses());  }}start();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Bitwise
Boolean

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36

Browser/OS: Chrome 112 on Linux

View result in a separate tab

Test name	Executions per second
Bitwise	417.1 Ops/sec
Boolean	297.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

I'll break down the provided JSON benchmark definition, explain what's being tested, and discuss the pros and cons of each approach.

Benchmark Definition

The benchmark tests two different approaches to handle completion data for courses: using bitwise operations (Bitwise) versus using boolean values (Boolean).

CompletedCourses Class

This class is used in both test cases. It has three methods:

init: Initializes the _state array, which stores the completion status of each course.
completeCourse(index): Sets the completion status of a specific course to true at the specified index in the _state array.
getCompletedCourses(index): Returns an array of courses completed by the student at the specified index.

CompletedCoursesBits Class

This class is used only in the Bitwise test case. It has three methods:

initBits(): Initializes the _status variable, which stores the completion status using bitwise operations.
completeCourseBit(index): Sets the completion status of a specific course to true by performing a bitwise OR operation on the _status variable.
getCompletedCoursesByBits(): Returns an array of courses completed by the student at each index by performing a bitwise AND operation between the _status variable and a mask.

Test Cases

There are two test cases:

Bitwise: This test case uses the CompletedCoursesBits class to complete courses using bitwise operations. It creates n students, each with an instance of CompletedCoursesBits, and then completes courses for each student using the completeCourseBit() method. Finally, it retrieves the completed courses by performing a bitwise AND operation on the _status variable.
Boolean: This test case uses the CompletedCourses class to complete courses using boolean values. It creates n students, each with an instance of CompletedCourses, and then completes courses for each student using the completeCourse() method. Finally, it retrieves the completed courses by calling the getCompletedCourses() method.

Pros and Cons

Bitwise Approach:

Pros:

Can potentially be faster due to bitwise operations being more efficient than boolean comparisons.
May use less memory since the _status variable can store multiple completion statuses in a single byte.

Cons:

Requires additional effort to manage the bit mask, which can increase complexity.
May not be as readable or maintainable for those unfamiliar with bitwise operations.

Boolean Approach:

Pros:

More intuitive and easier to understand for developers without experience with bitwise operations.
Requires less additional effort to implement and maintain.

Cons:

May be slower due to the overhead of boolean comparisons.

Other Considerations

Both approaches have their trade-offs. The Bitwise approach may offer a performance advantage, but requires more expertise in bitwise operations. The Boolean approach is more readable and maintainable, but may come at the cost of slower execution.

Library Used

The filter() method is used in both test cases to retrieve completed courses. This is a built-in JavaScript array method that returns a new array with all elements that pass the test implemented by the provided function.

There are no special JS features or syntax explicitly mentioned in this benchmark definition.

LLMs can make mistakes. Check important info.

I'll break down the provided JSON benchmark definition, explain what's being tested, and discuss the pros and cons of each approach.

**Benchmark Definition**

The benchmark tests two different approaches to handle completion data for courses: using bitwise operations (Bitwise) versus using boolean values (Boolean).

**CompletedCourses Class**

This class is used in both test cases. It has three methods:

1. `init`: Initializes the `_state` array, which stores the completion status of each course.
2. `completeCourse(index)`: Sets the completion status of a specific course to true at the specified index in the `_state` array.
3. `getCompletedCourses(index)`: Returns an array of courses completed by the student at the specified index.

**CompletedCoursesBits Class**

This class is used only in the Bitwise test case. It has three methods:

1. `initBits()`: Initializes the `_status` variable, which stores the completion status using bitwise operations.
2. `completeCourseBit(index)`: Sets the completion status of a specific course to true by performing a bitwise OR operation on the `_status` variable.
3. `getCompletedCoursesByBits()`: Returns an array of courses completed by the student at each index by performing a bitwise AND operation between the `_status` variable and a mask.

**Test Cases**

There are two test cases:

1. **Bitwise**: This test case uses the CompletedCoursesBits class to complete courses using bitwise operations. It creates `n` students, each with an instance of CompletedCoursesBits, and then completes courses for each student using the `completeCourseBit()` method. Finally, it retrieves the completed courses by performing a bitwise AND operation on the `_status` variable.
2. **Boolean**: This test case uses the CompletedCourses class to complete courses using boolean values. It creates `n` students, each with an instance of CompletedCourses, and then completes courses for each student using the `completeCourse()` method. Finally, it retrieves the completed courses by calling the `getCompletedCourses()` method.

**Pros and Cons**

**Bitwise Approach:**

Pros:

* Can potentially be faster due to bitwise operations being more efficient than boolean comparisons.
* May use less memory since the `_status` variable can store multiple completion statuses in a single byte.

Cons:

* Requires additional effort to manage the bit mask, which can increase complexity.
* May not be as readable or maintainable for those unfamiliar with bitwise operations.

**Boolean Approach:**

Pros:

* More intuitive and easier to understand for developers without experience with bitwise operations.
* Requires less additional effort to implement and maintain.

Cons:

* May be slower due to the overhead of boolean comparisons.

**Other Considerations**

**Library Used**

The `filter()` method is used in both test cases to retrieve completed courses. This is a built-in JavaScript array method that returns a new array with all elements that pass the test implemented by the provided function.

There are no special JS features or syntax explicitly mentioned in this benchmark definition.

Related benchmarks:

Bitwise vs Boolean data handling (version: 0)

Comparing performance of: Bitwise vs Boolean

Created: 6 years ago by: Registered User

Jump to the latest result

Bitwise

Boolean

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):