Faculty of Computing
SE-314: Software Construction
Class: BESE 13AB
Concurrency
Date: 09th Dec 2024
Assignment No 3
Instructor: Dr. Mehvish Rashid
Name CMS ID
Asna Maqsood 426990
Muhammad Owais Khan 404262
Umar Farooq 406481
Zainab Athar 405094
Contents
Concurrency Attainment in Software Systems..............................................................1
Web Servers............................................................................................................... 1
Database Systems...................................................................................................... 4
Batch Processing Systems.......................................................................................... 6
Microservices Architecture......................................................................................... 9
Operating Systems................................................................................................... 13
Distributed Systems................................................................................................. 16
Video/Graphics Rendering Systems..........................................................................19
Simulation Software................................................................................................. 22
Real-Time Communication Systems.........................................................................24
Containers and Virtualization Systems.....................................................................27
from flask import Flask, request
import threading
app = Flask(__name__)
def handle_request(client_id):
# Simulate processing time
print(f"Processing request from Client {client_id}")
import time
time.sleep(2)
print(f"Completed request from Client {client_id}")
@app.route('/process', methods=['GET'])
def process_request():
client_id = request.args.get('client_id', 'unknown')
thread = threading.Thread(target=handle_request, args=(client_id,))
thread.start()
return f"Request from Client {client_id} is being processed!"
if __name__ == '__main__':
app.run(threaded=True) # Enable multithreading
const http = require('http');
const server = http.createServer((req, res) => {
if (req.url === '/process') {
console.log('Processing request...');
setTimeout(() => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end('Request processed successfully!');
}, 2000); // Simulate async operation
} else {
res.writeHead(404, { 'Content-Type': 'text/plain' });
res.end('Not Found');
}
});
server.listen(3000, () => {
console.log('Server is listening on port 3000');
});
-- Transaction 1
START TRANSACTION;
SELECT balance FROM accounts WHERE account_id = 1 FOR UPDATE; -- Exclusive lock
UPDATE accounts SET balance = balance - 500 WHERE account_id = 1;
COMMIT;
-- Transaction 2
START TRANSACTION;
SELECT balance FROM accounts WHERE account_id = 1 FOR UPDATE; -- Waits until Transaction 1 is
committed
UPDATE accounts SET balance = balance + 500 WHERE account_id = 2;
COMMIT;
-- Transaction 1: Sets an isolation level
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
START TRANSACTION;
SELECT balance FROM accounts WHERE account_id = 1;
-- Transaction 2: Tries to update the same record
START TRANSACTION;
UPDATE accounts SET balance = balance + 100 WHERE account_id = 1; -- Blocked until Transaction 1
commits or rolls back
-- Commit or Rollback Transaction 1 to release the lock
COMMIT;
-- Transaction for User A
START TRANSACTION;
SELECT balance FROM accounts WHERE account_id = 1 FOR UPDATE; -- Locks the row
IF balance >= 500 THEN
UPDATE accounts SET balance = balance - 500 WHERE account_id = 1;
END IF;
COMMIT;
-- Transaction for User B
START TRANSACTION;
SELECT balance FROM accounts WHERE account_id = 1 FOR UPDATE; -- Waits until User A's transaction
completes
IF balance >= 300 THEN
UPDATE accounts SET balance = balance - 300 WHERE account_id = 1;
END IF;
COMMIT;
from multiprocessing import Pool
def compute_payroll(employee_id):
print(f"Processing payroll for employee {employee_id}")
# Simulate computation
return f"Payroll computed for employee {employee_id}"
if __name__ == "__main__":
employees = [101, 102, 103, 104, 105]
# Create a pool of workers
with Pool(processes=4) as pool:
results = pool.map(compute_payroll, employees)
for result in results:
print(result)
from pyspark.sql import SparkSession
# Initialize Spark session
spark = SparkSession.builder.appName("PayrollProcessing").getOrCreate()
# Load employee data
data = [("John", 1000), ("Alice", 1200), ("Bob", 900), ("Jane", 1100)]
columns = ["Name", "Salary"]
employee_df = spark.createDataFrame(data, columns)
# Define a function to compute bonuses
def compute_bonus(salary):
return salary * 0.1 # 10% bonus
# Apply transformation in parallel
employee_df = employee_df.withColumn("Bonus", employee_df["Salary"] * 0.1)
# Show results
employee_df.show()
# Stop Spark session
spark.stop()
Name Salary Bonus
John 1000 100.0
Alice 1200 120.0
Bob 900 90.0
Jane 1100 110.0
"public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {" (“MapReduce-
Demo/src/main/java/mapReduceTest/wordCount/WordCount ... - GitHub”)
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
public void map(Object key, Text value, Context context) throws IOException, InterruptedException {
StringTokenizer itr = new StringTokenizer(value.toString());
while (itr.hasMoreTokens()) {
word.set(itr.nextToken());
context.write(word, one);
}
}
}
"public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> {" (“Testing
your Hadoop program with Maven on IntelliJ - Medium”)
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException,
InterruptedException { (“WordCount.java - GitHub”)
int sum = 0;
for (IntWritable val : values) {
sum += val.get();
}
result.set(sum);
context.write(key, result);
}
}
version: '3.8'
services:
order-service:
image: order-service:latest
ports:
- "8081:8081"
depends_on:
- db
payment-service:
image: payment-service:latest
ports:
- "8082:8082"
depends_on:
- db
notification-service:
image: notification-service:latest
ports:
- "8083:8083"
db:
image: postgres:latest
environment:
POSTGRES_USER: admin
POSTGRES_PASSWORD: secret
import pika
def send_message():
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# Declare the queue
channel.queue_declare(queue='order_queue')
# Publish a message
message = "New order received"
channel.basic_publish(exchange='', routing_key='order_queue', body=message)
print(f"Sent: {message}")
connection.close()
if __name__ == "__main__":
send_message()
import pika
def receive_message():
connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()
# Declare the queue
channel.queue_declare(queue='order_queue')
def callback(ch, method, properties, body):
print(f"Received: {body.decode()}")
# Consume messages
channel.basic_consume(queue='order_queue', on_message_callback=callback, auto_ack=True)
print('Waiting for messages...')
channel.start_consuming()
if __name__ == "__main__":
receive_message()
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
public class OrderProducer {
public static void main(String[] args) {
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
Producer<String, String> producer = new KafkaProducer<>(props);
String topic = "order-events";
String key = "order1";
String value = "Order placed successfully";
producer.send(new ProducerRecord<>(topic, key, value), (metadata, exception) -> {
if (exception == null) {
System.out.println("Event sent: " + value);
} else {
exception.printStackTrace();
}
});
producer.close();
}
}
import org.apache.kafka.clients.consumer.*;
import java.util.Collections;
import java.util.Properties;
public class OrderConsumer {
public static void main(String[] args) {
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "order-group");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
Consumer<String, String> consumer = new KafkaConsumer<>(props);
consumer.subscribe(Collections.singletonList("order-events"));
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records) {
System.out.printf("Received event: %s%n", record.value());
}
}
}
}
import time
# Simulated processes with execution times
processes = [("Process A", 5), ("Process B", 3), ("Process C", 4)]
time_quantum = 2 # Time slice per process
def round_robin(processes, time_quantum):
while processes:
process, time_left = processes.pop(0)
print(f"Running {process} for {min(time_left, time_quantum)} seconds...")
time.sleep(min(time_left, time_quantum)) # Simulate process execution time
remaining_time = time_left - time_quantum
if remaining_time > 0:
processes.append((process, remaining_time)) # Re-add process if more time is needed
else:
print(f"{process} has finished execution.")
# Simulate round-robin scheduling
round_robin(processes, time_quantum)
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
// Simulate an interrupt service routine
void handle_interrupt(int signal) {
printf("Interrupt received! Handling the interrupt...\n");
}
int main() {
// Set up the interrupt handler for SIGINT (Ctrl+C)
signal(SIGINT, handle_interrupt);
printf("Program running. Press Ctrl+C to send an interrupt.\n");
// Simulate ongoing tasks in the system
while (1) {
printf("Performing task...\n");
sleep(1); // Simulate task processing
}
return 0;
}
from pyspark import SparkContext
# Initialize a Spark context
sc = SparkContext("local", "Distributed Computation Example")
# Create a distributed dataset (Resilient Distributed Dataset - RDD)
data = sc.parallelize([1, 2, 3, 4, 5])
# Perform a parallel computation (e.g., sum of squares)
squared_sum = data.map(lambda x: x ** 2).reduce(lambda a, b: a + b)
print(f"Sum of squares: {squared_sum}")
# Stop the Spark context
sc.stop()
import random
import time
from threading import Thread
class RaftNode:
def __init__(self, id):
self.id = id
self.state = "follower"
self.votes = 0
def start(self):
print(f"Node {self.id} started as {self.state}.")
while True:
if self.state == "follower":
# Simulating election timeout
time.sleep(random.uniform(1, 3))
self.state = "candidate"
self.votes = 1
print(f"Node {self.id} became a candidate and started election.")
self.elect_leader()
def elect_leader(self):
# Simulating voting process in Raft
if random.choice([True, False]): # Random decision to vote
print(f"Node {self.id} voted for a leader.")
self.votes += 1
if self.votes > 2: # Assume 3 nodes for simplicity
self.state = "leader"
print(f"Node {self.id} became the leader.")
# Create and start multiple Raft nodes
nodes = [RaftNode(id) for id in range(3)]
threads = [Thread(target=node.start) for node in nodes]
for thread in threads:
thread.start()
import time
import multiprocessing
# Simulate rendering a frame (just a placeholder for actual computation)
def render_frame(frame_number):
print(f"Rendering frame {frame_number}...")
time.sleep(0.5) # Simulating rendering time
print(f"Frame {frame_number} rendered.")
def render_video(total_frames):
# Create a pool of processes to render the frames concurrently
with multiprocessing.Pool(processes=4) as pool:
pool.map(render_frame, range(total_frames))
# Simulate rendering a video with 10 frames
render_video(10)
#include <iostream>
#include <cuda_runtime.h>
// A simple kernel to simulate rendering a pixel
__global__ void renderPixel(int *image, int width, int height) {
int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;
if (x < width && y < height) {
int index = y * width + x;
image[index] = x + y; // Placeholder for actual pixel color computation
}
}
int main() {
int width = 1920;
int height = 1080;
int image_size = width * height * sizeof(int);
int *d_image;
// Allocate memory on the GPU
cudaMalloc((void **)&d_image, image_size);
// Define grid and block size
dim3 threadsPerBlock(16, 16);
dim3 numBlocks((width + 15) / 16, (height + 15) / 16);
// Launch kernel to render the image
renderPixel<<<numBlocks, threadsPerBlock>>>(d_image, width, height);
// Copy the result back to host memory
int *h_image = new int[width * height];
cudaMemcpy(h_image, d_image, image_size, cudaMemcpyDeviceToHost);
// Clean up
cudaFree(d_image);
delete[] h_image;
std::cout << "Rendering complete!" << std::endl;
return 0;
}
import time
import multiprocessing
# Simulate vehicle movement (just a placeholder for actual movement logic)
def simulate_vehicle(vehicle_id):
print(f"Vehicle {vehicle_id} moving...")
time.sleep(0.2) # Simulating time taken for the vehicle to move
print(f"Vehicle {vehicle_id} reached destination.")
def simulate_traffic(total_vehicles):
# Create a pool of processes to simulate vehicle movements concurrently
with multiprocessing.Pool(processes=4) as pool:
pool.map(simulate_vehicle, range(total_vehicles))
# Simulate a traffic flow of 10 vehicles
simulate_traffic(10)
import threading
import time
# Simulate an agent (vehicle) moving through traffic
def vehicle_agent(vehicle_id):
print(f"Vehicle {vehicle_id} entering traffic...")
time.sleep(0.3) # Simulate time taken for the vehicle to make a move
print(f"Vehicle {vehicle_id} exited traffic.")
def simulate_traffic_agents(total_agents):
threads = []
for i in range(total_agents):
# Create a new thread for each agent
thread = threading.Thread(target=vehicle_agent, args=(i,))
threads.append(thread)
thread.start()
# Wait for all threads to complete
for thread in threads:
thread.join()
# Simulate 5 vehicle agents
simulate_traffic_agents(5)
import threading
import time
# Function to simulate processing video stream
def process_video_stream():
for i in range(5):
print("Processing video frame...")
time.sleep(0.5) # Simulating frame processing time
# Function to simulate processing audio stream
def process_audio_stream():
for i in range(5):
print("Processing audio data...")
time.sleep(0.3) # Simulating audio data processing time
# Function to simulate handling chat messages
def process_chat_messages():
for i in range(5):
print("Processing chat message...")
time.sleep(0.4) # Simulating message processing time
# Main function to simulate video call
def start_video_call():
# Creating threads for video, audio, and chat processing
video_thread = threading.Thread(target=process_video_stream)
audio_thread = threading.Thread(target=process_audio_stream)
chat_thread = threading.Thread(target=process_chat_messages)
# Starting the threads
video_thread.start()
audio_thread.start()
chat_thread.start()
# Waiting for all threads to complete
video_thread.join()
audio_thread.join()
chat_thread.join()
# Start the video call simulation
start_video_call()
import asyncio
# Function to simulate sending video stream
async def send_video_stream():
for i in range(5):
print("Sending video frame...")
await asyncio.sleep(0.5) # Simulating network delay
# Function to simulate receiving audio stream
async def receive_audio_stream():
for i in range(5):
print("Receiving audio data...")
await asyncio.sleep(0.3) # Simulating network delay
# Function to simulate real-time communication
async def start_real_time_communication():
# Running video and audio functions concurrently
video_task = asyncio.create_task(send_video_stream())
audio_task = asyncio.create_task(receive_audio_stream())
# Wait for both tasks to finish
await asyncio.gather(video_task, audio_task)
# Start real-time communication simulation
asyncio.run(start_real_time_communication())
# Build a Docker image for an application
docker build -t myapp /path/to/Dockerfile
# Run the first container
docker run -d --name container1 myapp
# Run the second container concurrently
docker run -d --name container2 myapp
# List all running containers
docker ps
# Create a new VM
VBoxManage createvm --name "VM1" --register
# Configure the VM (e.g., allocate 2 GB RAM)
VBoxManage modifyvm "VM1" --memory 2048
# Start the first VM
VBoxManage startvm "VM1" --type headless
# Create another VM and start it concurrently
VBoxManage createvm --name "VM2" --register
VBoxManage modifyvm "VM2" --memory 2048
VBoxManage startvm "VM2" --type headless
