Open-source News

TikTok Owner Bytedance Goes Big On Open-Source Firmware

Phoronix - Thu, 03/09/2023 - 21:50
TikTok owner Bytedance this week hosted their CloudFW Open System Firmware Symposium in Beijing where they celebrated the launch of CloudFW 2.0 as they implement Coreboot to replace UEFI...

PipeWire 0.3.67 Fixes Stuttering For Some Bluetooth Devices

Phoronix - Thu, 03/09/2023 - 21:30
PipeWire 0.3.67 is now available as the latest version of this now widely used server by the Linux desktop for managing audio and video streams as an alternative to PulseAudio and JACK on the audio side...

Initial Batch Of Intel Graphics Driver Updates Queued For Linux 6.4

Phoronix - Thu, 03/09/2023 - 19:35
While less than one week since the Linux 6.3-rc1 release, already the first batch of Intel (i915) kernel graphics driver updates has been sent to DRM-Next for queuing until the Linux 6.4 merge window kicks off in two months...

Linux Patch Updated For Rumble Support On Latest Microsoft Xbox Controllers

Phoronix - Thu, 03/09/2023 - 19:17
Last year I wrote about a Google engineer working on rumble support for the latest Microsoft controllers in conjunction with Microsoft's Xbox team. That patch seemed to have fallen through the woodwork but has been updated and sent out in "v2" form this week for allowing Linux gamers to enjoy rumble functionality with these latest Microsoft controllers...

Ruby Lands New "RJIT" Just-In-Time Compiler

Phoronix - Thu, 03/09/2023 - 19:03
Back in 2021 Ruby merged the YJIT just-in-time compiler that last year with Ruby 3.2 was deemed production grade. There's also been the MJIT compiler that relies upon an external C compiler. And now landing this week in Ruby is RJIT as the newest just-in-time effort...

Postgres DevOps database administrator: A day in the life

opensource.com - Thu, 03/09/2023 - 16:00
Postgres DevOps database administrator: A day in the life doug.ortiz Thu, 03/09/2023 - 03:00

A Postgres DevOps DBA plays a critical role in modern IT organizations that rely on Postgres as their primary database management system. The role of a Postgres DevOps DBA involves many responsibilities, skills, and tasks. A few of these include: Managing the database design and architecture, infrastructure management, ensuring high availability, security, and performing routine maintenance tasks (tuning, backup and recovery, and monitoring).

This article summarizes the common responsibilities and skills expected of a Postgres DevOps DBA in today's enterprise environments.

Database design and architecture

Two primary responsibilities of a Postgres DevOps DBA are database design and architecture. This role must have a greater understanding of the application's data storage requirements and the business logic involved. This knowledge includes designing and creating database schemas and tables. It also means configuring indexes and other database objects to optimize query performance, and choosing the right version of Postgres to use. The role must ensure the database is designed for scalability and maintainability, considering future growth and data retention needs.

Performance tuning

Another critical area of responsibility is performance tuning. A Postgres DevOps DBA must be able to identify and resolve performance issues by monitoring database performance metrics and analyzing query performance. The role must also have a deep understanding of the database and be able to configure it for optimal performance, including optimizing queries and indexes, tuning memory settings, and identifying and addressing performance bottlenecks.

Backup and recovery

Backup and recovery are also key areas of responsibility. The DBA must have a solid understanding of backup and recovery solutions and must design and implement a backup strategy that ensures that data is always recoverable in the event of data loss. They must also validate the recovery process and implement high-availability and disaster recovery solutions to minimize downtime and data loss.

Security

Security is another critical area of responsibility. The DBA ensures the database is secure by implementing access controls, encryption, and other security measures to protect the data. They must also stay up-to-date with the latest security trends and best practices and implement them to protect against potential threats.

Infrastructure management

Infrastructure management is also a key responsibility. These DBAs must manage the hardware, network, and storage infrastructure and provision the infrastructure to support Postgres. They must also configure the infrastructure for performance and availability and scale the infrastructure as necessary to accommodate data growth.

[ Related read: 3 tips to manage large Postgres databases ]

Automation and scripting

This role must be able to automate repetitive tasks such as backups, monitoring, and patching using tools like Ansible, Terraform, and Kubernetes. They must also be familiar with automation best practices to ensure tasks are automated efficiently and effectively. Automation reduces the potential for human error, improves efficiency, and allows the DBA to focus on more complex tasks.

More open source career advice Open source cheat sheets Linux starter kit for developers 7 questions sysadmins should ask a potential employer before taking a job Resources for IT artchitects Cheat sheet: IT job interviews Monitor and configure alerts

Monitoring the database and infrastructure and setting up alerts to notify them of issues is extremely important. The role must also take proactive measures to prevent downtime and data loss, using monitoring tools like Nagios, Zabbix, and Prometheus to detect potential issues.

Collaboration

In addition to these technical responsibilities, a PostgreSQL DevOps DBA must also collaborate with other IT teams, such as developers, operations, and security, to integrate the database into the larger IT ecosystem. The DBAs must also document their work and stay up-to-date with the latest trends and best practices in Postgres and DevOps. This involves engaging with stakeholders to gather requirements, establish priorities, and align the database with the organization's broader goals.

Wrap up

In conclusion, a Postgres DevOps DBA plays a critical role in modern IT organizations that rely on Postgres as their primary database management system. How do your current skills and expectations match this list? Are you on the right track to excel as a DBA in modern database environment?

What are the responsibilities of a database administrator (DBA)?

Image by:

opensource.com

Careers Databases What to read next MariaDB and MySQL cheat sheet This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License. Register or Login to post a comment.

Contribute to open source without code

opensource.com - Thu, 03/09/2023 - 16:00
Contribute to open source without code Debra Chen Thu, 03/09/2023 - 03:00

An open source "community" means different things to different people. I think of open source a little like "falling in love" because it is about people and relationships. Treat open source as a community because, without people, there is no source, open or otherwise.

I'm a member of the Apache DolphinScheduler community. Because that project is intentionally low-code, it appeals to many people who aren't software developers. Sometimes, people who don't write code aren't sure whether there's a meaningful way to contribute to an open source project that exists mainly because of source code. I know from experience that there is, and I will explain why in this article.

Contributions to the community

In the Apache DolphinScheduler project, I'm mainly responsible for global operation, influence, and caring for the community.

Some people say that projects are big trees, with open source being the soil. That's an apt analogy, and it demonstrates the importance of actively nurturing the thing you're trying to help grow.

I have a simpler idea: Do everything possible to make it good.

A community requires constant attention, not because it's needy but because it is part of life. Community is the people living amongst you, whether in your physical or online space.

Since joining the open source community, I have independently initiated and organized events, including:

  • Coordinated on average one meetup in China a month.
  • Recommended the community participate in the technology shares within the big data field.
  • Coordinated with almost all of the open source projects within China's "big data" field, visiting and communicating with those communities individually.

In my opinion, an excellent project should grow in a good ecology. And a community needs to go out to exchange ideas, share resources, and cooperate with other excellent communities. Everyone should feel the benefits brought to the community in their work.

My overseas expansion follows the same pattern. Of course, it's difficult to do that effectively due to differences in cultures and languages. It takes energy, but it's worth it.

So far, we have successfully held meetups overseas, including in the United States, India, Singapore, Germany, France, Finland, and more.

So how do I contribute to DolphinScheduler? Am I committing code to the project? Am I a community manager? Do I have an official title?

I think of myself as an assistant. I foster communication and connection, and that, as much as any code contribution, is an example of the "Apache Way."

Get started with DolphinScheduler

I first learned about open source when I worked at OpenAtom Foundation as an open source education operation manager. As China's first open source foundation, OpenAtom operates many projects, exemplified by OpenHarmony.

I joined the DolphinScheduler community and found a group of people who were eager to share knowledge, provide guidance and support, and keen to help others discover a tool they would find useful in their own lives.

DolphinScheduler aims to be an influential scheduler worldwide, helping teams work in an Agile and efficient way.

First impressions of the community

It's common to hear complaints from the community about project development. We all have complaints from time to time. Maybe you reported a bug, but the developers didn't address your problem. Or maybe you had a great idea for a feature, but the team ignored it. If you're a member of an open source community, you've heard these grievances before, and if you haven't, you eventually will.

I've learned that these voices are all important to an open source community. It's a good sign when you hear this feedback because it means the community is willing to find bugs, report them, and ask and answer questions. Hearing those complaints may reveal places in the project's structure that need to be improved. Is there a volunteer from the community who can respond to bug reports and triage them so they get to the right developer? Is there a volunteer group waiting to be formed to respond promptly to questions from newcomers in your project's Discourse or forum?

A greeter at the door of your open source project can help invite tentative community members in. A greeter can also ensure that there's no "gatekeeping" happening. Everyone's welcome and everyone has something to contribute, even if all they can offer is an atmosphere of helping one another.

As much as you or I wish we could solve technical issues for everyone, it's not practical. But anyone can be willing to help find a solution—that's one of the great strengths of a community. These users spontaneously serve as their community's "customer service" department.

Within the DolphinScheduler project, we have many (Yan Jiang, Xu Zhiwu, Zhang Qichen, Wang Yuxiang, Xiang Zihao, Yang Qiyu, Yang Jiahao, Gao Chufeng, and Gao Feng, in no particular order!). Even though they don't develop the solution, they work tirelessly to find the person who can.

Our favorite resources about open source Git cheat sheet Advanced Linux commands cheat sheet Open source alternatives Free online course: RHEL technical overview Check out more cheat sheets Words to the community

If you want to become a committer through non-code contributions or don't have time to make a code contribution, then the first step is to join the community. There's no sign-up form or approval process, but there's also no fast track. You join a community by participating. Through reliable and consistent participation, you develop relationships with others.

I'm available for a chat and always eager to talk about global event organization, documentation, feedback, and more.

Become a committer

Apache DolphinScheduler faces many challenges. Many companies, even ones that support open source, choose non-open business tooling. I want to work with community partners to make DolphinScheduler a world-class scheduling tool. I hope everyone can harvest the technical achievements they want and that DolphinScheduler helps get them there.

Join our community and help us promote an open and Agile way of working. Or find a project in need of your non-coding skills. Find out just how cool and fun it is to empower a community of your peers!

If you want to become a committer through non-code contributions or don't have time to make a code contribution, then the first step is to join the community.

Image by:

(WordPress, CC0 License)

Community management Careers What to read next This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License. Register or Login to post a comment.

Compiler optimization and its effect on debugger line information

opensource.com - Thu, 03/09/2023 - 16:00
Compiler optimization and its effect on debugger line information wcohen Thu, 03/09/2023 - 03:00

In my previous article, I described the DWARF information used to map regular and inlined functions between an executable binary and its source code. Functions can be dozens of lines, so you might like to know specifically where the processor is in your source code. The compiler includes information mapping between instructions and specific lines in the source code to provide a precise location. In this article, I describe line mapping information, and some of the issues caused by compiler optimizations.

Start with the same example code from the previous article:

#include #include int a; double b; int main(int argc, char* argv[]) { a = atoi(argv[1]); b = atof(argv[2]); a = a + 1; b = b / 42.0; printf ("a = %d, b = %f\n", a, b); return 0; }

The compiler only includes the line mapping information when the code is compiled with debugging information enabled (the -g option):

$ gcc -O2 -g example.c -o exampleExamining line number information

Line information is stored in a machine readable format, but human readable output can be generated with llvm-objdump or odjdump.

$ llvm-objdump --line-numbers example

For the main function, you get output listing the assembly code instruction with the file and line number associated with the instruction:

0000000000401060 : ; main(): ; /home/wcohen/present/202207youarehere/example.c:9 401060: 53 pushq %rbx ; /usr/include/stdlib.h:364 401061: 48 8b 7e 08 movq 8(%rsi), %rdi ; /home/wcohen/present/202207youarehere/example.c:9 401065: 48 89 f3 movq %rsi, %rbx ; /usr/include/stdlib.h:364 401068: ba 0a 00 00 00 movl $10, %edx 40106d: 31 f6 xorl %esi, %esi 40106f: e8 dc ff ff ff callq 0x401050 ; /usr/include/bits/stdlib-float.h:27 401074: 48 8b 7b 10 movq 16(%rbx), %rdi 401078: 31 f6 xorl %esi, %esi ; /usr/include/stdlib.h:364 40107a: 89 05 c8 2f 00 00 movl %eax, 12232(%rip) # 0x404048 ; /usr/include/bits/stdlib-float.h:27 401080: e8 ab ff ff ff callq 0x401030 ; /home/wcohen/present/202207youarehere/example.c:12 401085: 8b 05 bd 2f 00 00 movl 12221(%rip), %eax # 0x404048 ; /home/wcohen/present/202207youarehere/example.c:14 40108b: bf 10 20 40 00 movl $4202512, %edi # imm = 0x402010 ; /home/wcohen/present/202207youarehere/example.c:13 401090: f2 0f 5e 05 88 0f 00 00 divsd 3976(%rip), %xmm0 # 0x402020 <__dso_handle+0x18> 401098: f2 0f 11 05 a0 2f 00 00 movsd %xmm0, 12192(%rip) # 0x404040 ; /home/wcohen/present/202207youarehere/example.c:12 4010a0: 8d 70 01 leal 1(%rax), %esi ; /home/wcohen/present/202207youarehere/example.c:14 4010a3: b8 01 00 00 00 movl $1, %eax ; /home/wcohen/present/202207youarehere/example.c:12 4010a8: 89 35 9a 2f 00 00 movl %esi, 12186(%rip) # 0x404048 ; /home/wcohen/present/202207youarehere/example.c:14 4010ae: e8 8d ff ff ff callq 0x401040 ; /home/wcohen/present/202207youarehere/example.c:16 4010b3: 31 c0 xorl %eax, %eax 4010b5: 5b popq %rbx 4010b6: c3

The first instruction at 0x401060 maps to the original source code file example.c line 9, the opening { for the main function.

The next instruction 0x401061 maps to line 364 of stdlib.h line 364, the inlined atoi function. This is setting up one of the arguments to the later strtol call.

The instruction 0x401065 is also associated with the opening { of the main function.

Instructions 0x401068 and 0x40106d set the remaining arguments for the strtol call that takes place at 0x40106f. In this case, you can see that the compiler has reordered the instructions and causes some bouncing between line 9 of example.c and line 364, or the stdlib.h include file, as you step through the instructions on the debugger.

You can also see some mixing of instructions for lines 12, 13, and 14 from example.c in the output of llvm-objdump above. The compiler has moved the divide instructions (0x40190) for line 13 before some of the instructions for line 12 to hide the latency of the divide. As you step through the instructions in the debugger for this code, you see the debugger jump back and forth between lines rather than doing all the instructions from one line before moving on to the next line. Also notice as you step though that line 13 with the divide operation was not shown, but the divide definitely occurred to produce the output. You can see GDB bouncing between lines when stepping through the  program's main function:

(gdb) run 1 2 Starting program: /home/wcohen/present/202207youarehere/example 1 2 [Thread debugging using libthread_db enabled] Using host libthread_db library "/lib64/libthread_db.so.1". Breakpoint 1, main (argc=3, argv=0x7fffffffdbe8) at /usr/include/stdlib.h:364 364 return (int) strtol (__nptr, (char **) NULL, 10); (gdb) print $pc $10 = (void (*)()) 0x401060 (gdb) next 10 a = atoi(argv[1]); (gdb) print $pc $11 = (void (*)()) 0x401061 (gdb) next 11 b = atof(argv[2]); (gdb) print $pc $12 = (void (*)()) 0x401074 (gdb) next 10 a = atoi(argv[1]); (gdb) print $pc $13 = (void (*)()) 0x40107a (gdb) next 11 b = atof(argv[2]); (gdb) print $pc $14 = (void (*)()) 0x401080 (gdb) next 12 a = a + 1; (gdb) print $pc $15 = (void (*)()) 0x401085 (gdb) next 14 printf ("a = %d, b = %f\n", a, b); (gdb) print $pc $16 = (void (*)()) 0x4010ae (gdb) next a = 2, b = 0.047619 15 return 0; (gdb) print $pc $17 = (void (*)()) 0x4010b3

With this simple example, you can see that the order of instructions does not match the original source code. When the program is running normally, you would never observe those changes. However, they are quite visible when using a debugger to step through the code. The boundaries between lines of code become blurred. This has other implications. When you decide to set a breakpoint to a line following a line with variable update, the compiler scheduler may have moved the variable after the location you expect the variable to be updated, and you don’t get the expected value for the variable at the breakpoint.

Which of the instructions for a line get the breakpoint?

With the previous example.c, the compiler generated multiple instructions to implement individual lines of code. How does the debugger know which of those instructions should be the one that it places the breakpoint on? There’s an additional statement flag in the line information that marks the recommended locations to place the breakpoints. You can see those instructions marked with S in the column below SBPE in eu-readelf --debug-dump=decodedline example:

DWARF section [31] '.debug_line' at offset 0x50fd: CU [c] example.c line:col SBPE* disc isa op address (Statement Block Prologue Epilogue *End) /home/wcohen/present/202207youarehere/example.c (mtime: 0, length: 0) 9:1 S 0 0 0 0x0000000000401060 10:2 S 0 0 0 0x0000000000401060 /usr/include/stdlib.h (mtime: 0, length: 0) 362:1 S 0 0 0 0x0000000000401060 364:3 S 0 0 0 0x0000000000401060 /home/wcohen/present/202207youarehere/example.c (mtime: 0, length: 0) 9:1 0 0 0 0x0000000000401060 /usr/include/stdlib.h (mtime: 0, length: 0) 364:16 0 0 0 0x0000000000401061 364:16 0 0 0 0x0000000000401065 /home/wcohen/present/202207youarehere/example.c (mtime: 0, length: 0) 9:1 0 0 0 0x0000000000401065 /usr/include/stdlib.h (mtime: 0, length: 0) 364:16 0 0 0 0x0000000000401068 364:16 0 0 0 0x000000000040106f 364:16 0 0 0 0x0000000000401074 /usr/include/bits/stdlib-float.h (mtime: 0, length: 0) 27:10 0 0 0 0x0000000000401074 /usr/include/stdlib.h (mtime: 0, length: 0) 364:10 0 0 0 0x000000000040107a /home/wcohen/present/202207youarehere/example.c (mtime: 0, length: 0) 11:2 S 0 0 0 0x0000000000401080 /usr/include/bits/stdlib-float.h (mtime: 0, length: 0) 25:1 S 0 0 0 0x0000000000401080 27:3 S 0 0 0 0x0000000000401080 27:10 0 0 0 0x0000000000401080 27:10 0 0 0 0x0000000000401085 /home/wcohen/present/202207youarehere/example.c (mtime: 0, length: 0) 12:2 S 0 0 0 0x0000000000401085 12:8 0 0 0 0x0000000000401085 14:2 0 0 0 0x000000000040108b 13:8 0 0 0 0x0000000000401090 13:4 0 0 0 0x0000000000401098 12:8 0 0 0 0x00000000004010a0 14:2 0 0 0 0x00000000004010a3 12:4 0 0 0 0x00000000004010a8 13:2 S 0 0 0 0x00000000004010ae 14:2 S 0 0 0 0x00000000004010ae 15:2 S 0 0 0 0x00000000004010b3 16:1 0 0 0 0x00000000004010b3 16:1 0 0 0 0x00000000004010b6 16:1 * 0 0 0 0x00000000004010b6
  • Groups of instructions are delimited by the path to the source file for those instructions.
  • The left column contains the line number and column that the instruction maps back to, followed by the flags.
  • The hexadecimal number is the address of the instruction, followed by the offset into the function of the instruction.

If you look carefully at the output, you see that some instructions map back to multiple lines in the code. For example, 0x0000000000401060 maps to both line 9 and 10 of example.c. The same instruction also maps to lines 362 and 364 of /usr/include/stdlib.h. The mappings are not one-to-one. One line of source code may map to multiple instructions, and one instruction may map to multiple lines of code. When the debugger decides to print out a single line mapping for an instruction, it might not be the one that you expect.

Merging and eliminating of lines

As you saw in the output of the detailed line mapping information, mappings are not one-to-one. There are cases where the compiler can eliminate instructions because they have no effect on the final result of the program. The compiler may also merge instructions from separate lines through optimizations, such as common subexpression elimination (CSE), and omit that the instruction could have come from more than one place in the code.

The following example was compiled on an x86_64 Fedora 36 machine, using GCC-12.2.1. Depending on the particular environment, you may not get the same results, because different versions of compilers may optimize the code differently.

Note the if-else statement in the code. Both have statements doing the same expensive divides. The compiler factors out the divide operation.

#include #include int main(int argc, char* argv[]) { int a,b,c; a = atoi(argv[1]); b = atoi(argv[2]); if (b) { c = 100/a; } else { c = 100/a; } printf ("a = %d, b = %d, c = %d\n", a, b, c); return 0; }

Looking at objdump -dl whichline, you see one divide operation in the binary:

/home/wcohen/present/202207youarehere/whichline.c:13 401085: b8 64 00 00 00 mov $0x64,%eax 40108a: f7 fb idiv %ebx

Line 13 is one of the lines with a divide, but you might suspect that there are other line numbers associated with those addresses. Look at the output of eu-readelf --debug-dump=decodedline whichline to see whether there are other line numbers associated with those addresses.

Line 11, where the other divide occurs, is not in this list:

/usr/include/stdlib.h (mtime: 0, length: 0) 364:16 0 0 0 0x0000000000401082 364:16 0 0 0 0x0000000000401085 /home/wcohen/present/202207youarehere/whichline.c (mtime: 0, length: 0) 10:2 S 0 0 0 0x0000000000401085 13:3 S 0 0 0 0x0000000000401085 15:2 S 0 0 0 0x0000000000401085 13:5 0 0 0 0x0000000000401085

If the results are unused, the compiler may completely eliminate generating code for some lines.

Consider the following example, where the else clause computes c = 100 * a, but does not use it:

#include #include int main(int argc, char* argv[]) { int a,b,c; a = atoi(argv[1]); b = atoi(argv[2]); if (b) { c = 100/a; printf ("a = %d, b = %d, c = %d\n", a, b, c); } else { c = 100 * a; printf ("a = %d, b = %d\n", a, b); } return 0; }

Programming and development
Red Hat Developers Blog Programming cheat sheets Try for free: Red Hat Learning Subscription eBook: An introduction to programming with Bash Bash shell scripting cheat sheet eBook: Modernizing Enterprise Java An open source developer's guide to building applications

Compile eliminate.c with GCC:

$ gcc -O2 -g eliminate.c -o eliminate

When looking through the output generated by objdump -dl eliminate, there’s no sign of the multiplication for 100 * a (line 14) of eliminate.c. The compiler has determined that the value was not used and eliminated it.

When looking through the output of objdump -dl eliminate, there is no:

/home/wcohen/present/202207youarehere/eliminate.c:14

Maybe it’s hidden as one of the other views of line information. You can use eu-readelf with the --debug-dump option to get a complete view of the line information:

$ eu-readelf --debug-dump=decodedline eliminate > eliminate.lines

It turns out that GCC did record some mapping information. It seems that 0x4010a5 maps to the multiplication statement, in addition to the printf at line 15:

/home/wcohen/present/202207youarehere/eliminate.c (mtime: 0, length: 0) … 18:1 0 0 0 0x00000000004010a4 14:3 S 0 0 0 0x00000000004010a5 15:3 S 0 0 0 0x00000000004010a5 15:3 0 0 0 0x00000000004010b0 15:3 * 0 0 0 0x00000000004010b6 Optimization affects line information

The line information included into compiled binaries is helpful when pinpointing where in code the processor is. However, optimization can affect the line information, and what you see when debugging the code.

When using a debugger, expect that boundaries between lines of code are fuzzy, and the debugger is likely to bounce between them when stepping through the code. An instruction might map to multiple lines of source code, but the debugger may only reports one. The compiler may entirely eliminate instructions associated with a line of code, and it may or may not include line mapping information. The line information generated by the compiler is helpful, but keep in mind that something might be lost in translation.

Learn how to decipher the output of debugging line information, and what tools you can use to look deeper.

Image by:

Opensource.com

Programming What to read next What you need to know about compiling code This work is licensed under a Creative Commons Attribution-Share Alike 4.0 International License. Register or Login to post a comment.

Pydf – An Alternative “df” Command to Check Disk Usage in Different Colours

Tecmint - Thu, 03/09/2023 - 12:35
The post Pydf – An Alternative “df” Command to Check Disk Usage in Different Colours first appeared on Tecmint: Linux Howtos, Tutorials & Guides .

The “pydf” (Python Disk File System) is an advanced command line tool and a good alternative to the “df command”, which is used to display the amount of used and available disk space on

The post Pydf – An Alternative “df” Command to Check Disk Usage in Different Colours first appeared on Tecmint: Linux Howtos, Tutorials & Guides.

Open-Source AMD OpenGL Driver Drops Support For Smart Access Memory / ReBAR

Phoronix - Thu, 03/09/2023 - 07:30
Since late 2020 there had been work by AMD Linux engineers on adding Smart Access Memory (Resizable BAR) support to RadeonSI as the Gallium3D OpenGL driver and improved since that point in the name of performance. However, for this OpenGL driver now they've come to realize the benefits haven't necessarily panned out and the developers went ahead and disabled this SAM/ReBAR support followed by removing the support from this driver...

Pages